xref: /openbmc/phosphor-webui/app/common/services/api-utils.js (revision 1ffa209e99da608e225df0a3a3caf47036b3a793)
1/**
2 * API utilities service
3 *
4 * @module app/common/services/api-utils
5 * @exports APIUtils
6 * @name APIUtils
7 */
8
9window.angular && (function(angular) {
10  'use strict';
11  angular.module('app.common.services').factory('APIUtils', [
12    '$http', 'Constants', '$q', 'dataService', '$interval',
13    function($http, Constants, $q, DataService, $interval) {
14      var getScaledValue = function(value, scale) {
15        scale = scale + '';
16        scale = parseInt(scale, 10);
17        var power = Math.abs(parseInt(scale, 10));
18
19        if (scale > 0) {
20          value = value * Math.pow(10, power);
21        } else if (scale < 0) {
22          value = value / Math.pow(10, power);
23        }
24        return value;
25      };
26      var SERVICE = {
27        API_CREDENTIALS: Constants.API_CREDENTIALS,
28        API_RESPONSE: Constants.API_RESPONSE,
29        CHASSIS_POWER_STATE: Constants.CHASSIS_POWER_STATE,
30        HOST_STATE_TEXT: Constants.HOST_STATE,
31        HOST_STATE: Constants.HOST_STATE,
32        LED_STATE: Constants.LED_STATE,
33        LED_STATE_TEXT: Constants.LED_STATE_TEXT,
34        HOST_SESSION_STORAGE_KEY: Constants.API_CREDENTIALS.host_storage_key,
35        getChassisState: function() {
36          var deferred = $q.defer();
37          $http({
38            method: 'GET',
39            url: DataService.getHost() +
40                '/xyz/openbmc_project/state/chassis0/attr/CurrentPowerState',
41            withCredentials: true
42          })
43              .then(
44                  function(response) {
45                    var json = JSON.stringify(response.data);
46                    var content = JSON.parse(json);
47                    deferred.resolve(content.data);
48                  },
49                  function(error) {
50                    console.log(error);
51                    deferred.reject(error);
52                  });
53          return deferred.promise;
54        },
55        validIPV4IP: function(ip) {
56          // Checks for [0-255].[0-255].[0-255].[0-255]
57          return ip.match(
58              /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/);
59        },
60        getRedfishSysName: function() {
61          return $http({
62                   method: 'GET',
63                   url: DataService.getHost() + '/redfish/v1/Systems',
64                   withCredentials: true
65                 })
66              .then(
67                  function(response) {
68                    var sysUrl = response.data['Members'][0]['@odata.id'];
69                    return sysUrl.split('/').pop(-1);
70                  },
71                  function(error) {
72                    console.log(JSON.stringify(error));
73                  });
74        },
75        getSystemLogs: function(recordType) {
76          var uri = '/redfish/v1/Systems/' + DataService.systemName +
77              '/LogServices/EventLog/Entries';
78          return $http({
79                   method: 'GET',
80                   url: DataService.getHost() + uri,
81                   withCredentials: true
82                 })
83              .then(
84                  function(response) {
85                    var logEntries = [];
86                    angular.forEach(response.data['Members'], function(log) {
87                      if (log.hasOwnProperty('EntryType')) {
88                        if (log['EntryType'] == recordType) {
89                          logEntries.push(log);
90                        }
91                      }
92                    });
93                    return logEntries;
94                  },
95                  function(error) {
96                    console.log(JSON.stringify(error));
97                  });
98        },
99        clearSystemLogs: function() {
100          var uri = '/redfish/v1/Systems/' + DataService.systemName +
101              '/LogServices/EventLog/Actions/LogService.ClearLog';
102          return $http({
103            method: 'POST',
104            url: DataService.getHost() + uri,
105            withCredentials: true
106          });
107        },
108        deleteObject: function(path) {
109          return $http({
110                   method: 'POST',
111                   url: DataService.getHost() + path + '/action/Delete',
112                   withCredentials: true,
113                   data: JSON.stringify({'data': []})
114                 })
115              .then(function(response) {
116                return response.data;
117              });
118        },
119        getHostState: function() {
120          var deferred = $q.defer();
121          $http({
122            method: 'GET',
123            url: DataService.getHost() +
124                '/xyz/openbmc_project/state/host0/attr/CurrentHostState',
125            withCredentials: true
126          })
127              .then(
128                  function(response) {
129                    var json = JSON.stringify(response.data);
130                    var content = JSON.parse(json);
131                    deferred.resolve(content.data);
132                  },
133                  function(error) {
134                    console.log(error);
135                    deferred.reject(error);
136                  });
137          return deferred.promise;
138        },
139        getSNMPManagers: function() {
140          return $http({
141                   method: 'GET',
142                   url: DataService.getHost() +
143                       '/xyz/openbmc_project/network/snmp/manager/enumerate',
144                   withCredentials: true
145                 })
146              .then(function(response) {
147                return response.data;
148              });
149        },
150        pollHostStatusTillOn: function() {
151          var deferred = $q.defer();
152          var hostOnTimeout = setTimeout(function() {
153            ws.close();
154            deferred.reject(new Error(Constants.MESSAGES.POLL.HOST_ON_TIMEOUT));
155          }, Constants.TIMEOUT.HOST_ON);
156
157          var ws =
158              new WebSocket('wss://' + DataService.server_id + '/subscribe');
159          var data = JSON.stringify({
160            'paths': ['/xyz/openbmc_project/state/host0'],
161            'interfaces': ['xyz.openbmc_project.State.Host']
162          });
163          ws.onopen = function() {
164            ws.send(data);
165          };
166          ws.onmessage = function(evt) {
167            var content = JSON.parse(evt.data);
168            var hostState = content.properties.CurrentHostState;
169            if (hostState === Constants.HOST_STATE_TEXT.on_code) {
170              clearTimeout(hostOnTimeout);
171              ws.close();
172              deferred.resolve();
173            } else if (hostState === Constants.HOST_STATE_TEXT.error_code) {
174              clearTimeout(hostOnTimeout);
175              ws.close();
176              deferred.reject(new Error(Constants.MESSAGES.POLL.HOST_QUIESCED));
177            }
178          };
179        },
180
181        pollHostStatusTilReboot: function() {
182          var deferred = $q.defer();
183          var onState = Constants.HOST_STATE_TEXT.on_code;
184          var offState = Constants.HOST_STATE_TEXT.on_code;
185          var hostTimeout;
186          var setHostTimeout = function(message, timeout) {
187            hostTimeout = setTimeout(function() {
188              ws.close();
189              deferred.reject(new Error(message));
190            }, timeout);
191          };
192          var ws =
193              new WebSocket('wss://' + DataService.server_id + '/subscribe');
194          var data = JSON.stringify({
195            'paths': ['/xyz/openbmc_project/state/host0'],
196            'interfaces': ['xyz.openbmc_project.State.Host']
197          });
198          ws.onopen = function() {
199            ws.send(data);
200          };
201          setHostTimeout(
202              Constants.MESSAGES.POLL.HOST_OFF_TIMEOUT,
203              Constants.TIMEOUT.HOST_OFF);
204          var pollState = offState;
205          ws.onmessage = function(evt) {
206            var content = JSON.parse(evt.data);
207            var hostState = content.properties.CurrentHostState;
208            if (hostState === pollState) {
209              if (pollState === offState) {
210                clearTimeout(hostTimeout);
211                pollState = onState;
212                setHostTimeout(
213                    Constants.MESSAGES.POLL.HOST_ON_TIMEOUT,
214                    Constants.TIMEOUT.HOST_ON);
215              }
216              if (pollState === onState) {
217                clearTimeout(hostTimeout);
218                ws.close();
219                deferred.resolve();
220              }
221            } else if (hostState === Constants.HOST_STATE_TEXT.error_code) {
222              clearTimeout(hostTimeout);
223              ws.close();
224              deferred.reject(new Error(Constants.MESSAGES.POLL.HOST_QUIESCED));
225            }
226          };
227        },
228
229        pollHostStatusTillOff: function() {
230          var deferred = $q.defer();
231          var hostOffTimeout = setTimeout(function() {
232            ws.close();
233            deferred.reject(
234                new Error(Constants.MESSAGES.POLL.HOST_OFF_TIMEOUT));
235          }, Constants.TIMEOUT.HOST_OFF);
236
237          var ws =
238              new WebSocket('wss://' + DataService.server_id + '/subscribe');
239          var data = JSON.stringify({
240            'paths': ['/xyz/openbmc_project/state/host0'],
241            'interfaces': ['xyz.openbmc_project.State.Host']
242          });
243          ws.onopen = function() {
244            ws.send(data);
245          };
246          ws.onmessage = function(evt) {
247            var content = JSON.parse(evt.data);
248            var hostState = content.properties.CurrentHostState;
249            if (hostState === Constants.HOST_STATE_TEXT.off_code) {
250              clearTimeout(hostOffTimeout);
251              ws.close();
252              deferred.resolve();
253            }
254          };
255        },
256        addSNMPManager: function(address, port) {
257          return $http({
258                   method: 'POST',
259                   url: DataService.getHost() +
260                       '/xyz/openbmc_project/network/snmp/manager/action/Client',
261                   withCredentials: true,
262                   data: JSON.stringify({'data': [address, +port]})
263                 })
264              .then(function(response) {
265                return response.data;
266              });
267        },
268        setSNMPManagerPort: function(snmpManagerPath, port) {
269          return $http({
270                   method: 'PUT',
271                   url: DataService.getHost() + snmpManagerPath + '/attr/Port',
272                   withCredentials: true,
273                   data: JSON.stringify({'data': +port})
274                 })
275              .then(function(response) {
276                return response.data;
277              });
278        },
279        setSNMPManagerAddress: function(snmpManagerPath, address) {
280          return $http({
281                   method: 'PUT',
282                   url: DataService.getHost() + snmpManagerPath +
283                       '/attr/Address',
284                   withCredentials: true,
285                   data: JSON.stringify({'data': address})
286                 })
287              .then(function(response) {
288                return response.data;
289              });
290        },
291        getNetworkInfo: function() {
292          var deferred = $q.defer();
293          $http({
294            method: 'GET',
295            url: DataService.getHost() +
296                '/xyz/openbmc_project/network/enumerate',
297            withCredentials: true
298          })
299              .then(
300                  function(response) {
301                    var json = JSON.stringify(response.data);
302                    var content = JSON.parse(json);
303                    var hostname = '';
304                    var defaultgateway = '';
305                    var macAddress = '';
306
307                    function parseNetworkData(content) {
308                      var data = {
309                        interface_ids: [],
310                        interfaces: {},
311                        ip_addresses: {ipv4: [], ipv6: []},
312                      };
313                      var interfaceId = '', keyParts = [], interfaceHash = '',
314                          interfaceType = '';
315                      for (var key in content.data) {
316                        if (key.match(/network\/eth\d+(_\d+)?$/ig)) {
317                          interfaceId = key.split('/').pop();
318                          if (data.interface_ids.indexOf(interfaceId) == -1) {
319                            data.interface_ids.push(interfaceId);
320                            data.interfaces[interfaceId] = {
321                              interfaceIname: '',
322                              DomainName: '',
323                              MACAddress: '',
324                              Nameservers: [],
325                              DHCPEnabled: 0,
326                              ipv4: {ids: [], values: []},
327                              ipv6: {ids: [], values: []}
328                            };
329                            data.interfaces[interfaceId].MACAddress =
330                                content.data[key].MACAddress;
331                            data.interfaces[interfaceId].DomainName =
332                                content.data[key].DomainName.join(' ');
333                            data.interfaces[interfaceId].Nameservers =
334                                content.data[key].Nameservers;
335                            data.interfaces[interfaceId].DHCPEnabled =
336                                content.data[key].DHCPEnabled;
337                          }
338                        } else if (
339                            key.match(
340                                /network\/eth\d+(_\d+)?\/ipv[4|6]\/[a-z0-9]+$/ig)) {
341                          keyParts = key.split('/');
342                          interfaceHash = keyParts.pop();
343                          interfaceType = keyParts.pop();
344                          interfaceId = keyParts.pop();
345
346                          if (data.interfaces[interfaceId][interfaceType]
347                                  .ids.indexOf(interfaceHash) == -1) {
348                            data.interfaces[interfaceId][interfaceType]
349                                .ids.push(interfaceHash);
350                            data.interfaces[interfaceId][interfaceType]
351                                .values.push(content.data[key]);
352                            data.ip_addresses[interfaceType].push(
353                                content.data[key]['Address']);
354                          }
355                        }
356                      }
357                      return data;
358                    }
359
360                    if (content.data.hasOwnProperty(
361                            '/xyz/openbmc_project/network/config')) {
362                      if (content.data['/xyz/openbmc_project/network/config']
363                              .hasOwnProperty('HostName')) {
364                        hostname =
365                            content.data['/xyz/openbmc_project/network/config']
366                                .HostName;
367                      }
368                      if (content.data['/xyz/openbmc_project/network/config']
369                              .hasOwnProperty('DefaultGateway')) {
370                        defaultgateway =
371                            content.data['/xyz/openbmc_project/network/config']
372                                .DefaultGateway;
373                      }
374                    }
375
376                    if (content.data.hasOwnProperty(
377                            '/xyz/openbmc_project/network/eth0') &&
378                        content.data['/xyz/openbmc_project/network/eth0']
379                            .hasOwnProperty('MACAddress')) {
380                      macAddress =
381                          content.data['/xyz/openbmc_project/network/eth0']
382                              .MACAddress;
383                    }
384
385                    deferred.resolve({
386                      data: content.data,
387                      hostname: hostname,
388                      defaultgateway: defaultgateway,
389                      mac_address: macAddress,
390                      formatted_data: parseNetworkData(content)
391                    });
392                  },
393                  function(error) {
394                    console.log(error);
395                    deferred.reject(error);
396                  });
397          return deferred.promise;
398        },
399        setMACAddress: function(interface_name, mac_address) {
400          return $http({
401                   method: 'PUT',
402                   url: DataService.getHost() +
403                       '/xyz/openbmc_project/network/' + interface_name +
404                       '/attr/MACAddress',
405                   withCredentials: true,
406                   data: JSON.stringify({'data': mac_address})
407                 })
408              .then(function(response) {
409                return response.data;
410              });
411        },
412        setDefaultGateway: function(defaultGateway) {
413          return $http({
414                   method: 'PUT',
415                   url: DataService.getHost() +
416                       '/xyz/openbmc_project/network/config/attr/DefaultGateway',
417                   withCredentials: true,
418                   data: JSON.stringify({'data': defaultGateway})
419                 })
420              .then(function(response) {
421                return response.data;
422              });
423        },
424        setDHCPEnabled: function(interfaceName, dhcpEnabled) {
425          return $http({
426                   method: 'PUT',
427                   url: DataService.getHost() +
428                       '/xyz/openbmc_project/network/' + interfaceName +
429                       '/attr/DHCPEnabled',
430                   withCredentials: true,
431                   data: JSON.stringify({'data': dhcpEnabled})
432                 })
433              .then(function(response) {
434                return response.data;
435              });
436        },
437        setNameservers: function(interfaceName, dnsServers) {
438          return $http({
439                   method: 'PUT',
440                   url: DataService.getHost() +
441                       '/xyz/openbmc_project/network/' + interfaceName +
442                       '/attr/Nameservers',
443                   withCredentials: true,
444                   data: JSON.stringify({'data': dnsServers})
445                 })
446              .then(function(response) {
447                return response.data;
448              });
449        },
450        deleteIPV4: function(interfaceName, networkID) {
451          return $http({
452                   method: 'POST',
453                   url: DataService.getHost() +
454                       '/xyz/openbmc_project/network/' + interfaceName +
455                       '/ipv4/' + networkID + '/action/Delete',
456                   withCredentials: true,
457                   data: JSON.stringify({'data': []})
458                 })
459              .then(function(response) {
460                return response.data;
461              });
462        },
463        addIPV4: function(
464            interfaceName, ipAddress, netmaskPrefixLength, gateway) {
465          return $http({
466                   method: 'POST',
467                   url: DataService.getHost() +
468                       '/xyz/openbmc_project/network/' + interfaceName +
469                       '/action/IP',
470                   withCredentials: true,
471                   data: JSON.stringify({
472                     'data': [
473                       'xyz.openbmc_project.Network.IP.Protocol.IPv4',
474                       ipAddress, +netmaskPrefixLength, gateway
475                     ]
476                   })
477                 })
478              .then(function(response) {
479                return response.data;
480              });
481        },
482        getLEDState: function() {
483          var deferred = $q.defer();
484          $http({
485            method: 'GET',
486            url: DataService.getHost() +
487                '/xyz/openbmc_project/led/groups/enclosure_identify',
488            withCredentials: true
489          })
490              .then(
491                  function(response) {
492                    var json = JSON.stringify(response.data);
493                    var content = JSON.parse(json);
494                    deferred.resolve(content.data.Asserted);
495                  },
496                  function(error) {
497                    console.log(error);
498                    deferred.reject(error);
499                  });
500          return deferred.promise;
501        },
502        login: function(username, password, callback) {
503          $http({
504            method: 'POST',
505            url: DataService.getHost() + '/login',
506            withCredentials: true,
507            data: JSON.stringify({'data': [username, password]})
508          })
509              .then(
510                  function(response) {
511                    if (callback) {
512                      callback(response.data);
513                    }
514                  },
515                  function(error) {
516                    if (callback) {
517                      if (error && error.status && error.status == 'error') {
518                        callback(error);
519                      } else {
520                        callback(error, true);
521                      }
522                    }
523                    console.log(error);
524                  });
525        },
526        logout: function(callback) {
527          $http({
528            method: 'POST',
529            url: DataService.getHost() + '/logout',
530            withCredentials: true,
531            data: JSON.stringify({'data': []})
532          })
533              .then(
534                  function(response) {
535                    if (callback) {
536                      callback(response.data);
537                    }
538                  },
539                  function(error) {
540                    if (callback) {
541                      callback(null, error);
542                    }
543                    console.log(error);
544                  });
545        },
546        getAccountServiceRoles: function() {
547          var roles = [];
548
549          return $http({
550                   method: 'GET',
551                   url: DataService.getHost() +
552                       '/redfish/v1/AccountService/Roles',
553                   withCredentials: true
554                 })
555              .then(
556                  function(response) {
557                    var members = response.data['Members'];
558                    angular.forEach(members, function(member) {
559                      roles.push(member['@odata.id'].split('/').pop());
560                    });
561                    return roles;
562                  },
563                  function(error) {
564                    console.log(error);
565                  });
566        },
567        getAllUserAccounts: function() {
568          var deferred = $q.defer();
569          var promises = [];
570          var users = [];
571
572          $http({
573            method: 'GET',
574            url: DataService.getHost() + '/redfish/v1/AccountService/Accounts',
575            withCredentials: true
576          })
577              .then(
578                  function(response) {
579                    var members = response.data['Members'];
580                    angular.forEach(members, function(member) {
581                      promises.push(
582                          $http({
583                            method: 'GET',
584                            url: DataService.getHost() + member['@odata.id'],
585                            withCredentials: true
586                          }).then(function(res) {
587                            return res.data;
588                          }));
589                    });
590
591                    $q.all(promises).then(
592                        function(results) {
593                          deferred.resolve(results);
594                        },
595                        function(errors) {
596                          deferred.reject(errors);
597                        });
598                  },
599                  function(error) {
600                    console.log(error);
601                    deferred.reject(error);
602                  });
603          return deferred.promise;
604        },
605
606        getAllUserAccountProperties: function(callback) {
607          return $http({
608                   method: 'GET',
609                   url: DataService.getHost() + '/redfish/v1/AccountService',
610                   withCredentials: true
611                 })
612              .then(
613                  function(response) {
614                    return response.data;
615                  },
616                  function(error) {
617                    console.log(error);
618                  });
619        },
620
621        saveUserAccountProperties: function(lockoutduration, lockoutthreshold) {
622          var data = {};
623          if (lockoutduration != undefined) {
624            data['AccountLockoutDuration'] = lockoutduration;
625          }
626          if (lockoutthreshold != undefined) {
627            data['AccountLockoutThreshold'] = lockoutthreshold;
628          }
629
630          return $http({
631            method: 'PATCH',
632            url: DataService.getHost() + '/redfish/v1/AccountService',
633            withCredentials: true,
634            data: data
635          });
636        },
637
638        createUser: function(user, passwd, role, enabled) {
639          var data = {};
640          data['UserName'] = user;
641          data['Password'] = passwd;
642          data['RoleId'] = role;
643          data['Enabled'] = enabled;
644
645          return $http({
646            method: 'POST',
647            url: DataService.getHost() + '/redfish/v1/AccountService/Accounts',
648            withCredentials: true,
649            data: data
650          });
651        },
652        updateUser: function(user, newUser, passwd, role, enabled) {
653          var data = {};
654          if ((newUser !== undefined) && (newUser != null)) {
655            data['UserName'] = newUser;
656          }
657          if ((role !== undefined) && (role != null)) {
658            data['RoleId'] = role;
659          }
660          if ((enabled !== undefined) && (enabled != null)) {
661            data['Enabled'] = enabled;
662          }
663          if ((passwd !== undefined) && (passwd != null)) {
664            data['Password'] = passwd;
665          }
666          return $http({
667            method: 'PATCH',
668            url: DataService.getHost() +
669                '/redfish/v1/AccountService/Accounts/' + user,
670            withCredentials: true,
671            data: data
672          });
673        },
674        deleteUser: function(user) {
675          return $http({
676            method: 'DELETE',
677            url: DataService.getHost() +
678                '/redfish/v1/AccountService/Accounts/' + user,
679            withCredentials: true,
680          });
681        },
682        chassisPowerOff: function() {
683          var deferred = $q.defer();
684          $http({
685            method: 'PUT',
686            url: DataService.getHost() +
687                '/xyz/openbmc_project/state/chassis0/attr/RequestedPowerTransition',
688            withCredentials: true,
689            data: JSON.stringify(
690                {'data': 'xyz.openbmc_project.State.Chassis.Transition.Off'})
691          })
692              .then(
693                  function(response) {
694                    var json = JSON.stringify(response.data);
695                    var content = JSON.parse(json);
696                    deferred.resolve(content.status);
697                  },
698                  function(error) {
699                    console.log(error);
700                    deferred.reject(error);
701                  });
702          return deferred.promise;
703        },
704        setLEDState: function(state) {
705          return $http({
706            method: 'PUT',
707            url: DataService.getHost() +
708                '/xyz/openbmc_project/led/groups/enclosure_identify/attr/Asserted',
709            withCredentials: true,
710            data: JSON.stringify({'data': state})
711          })
712        },
713        bmcReboot: function(callback) {
714          $http({
715            method: 'PUT',
716            url: DataService.getHost() +
717                '/xyz/openbmc_project/state/bmc0/attr/RequestedBMCTransition',
718            withCredentials: true,
719            data: JSON.stringify(
720                {'data': 'xyz.openbmc_project.State.BMC.Transition.Reboot'})
721          })
722              .then(
723                  function(response) {
724                    var json = JSON.stringify(response.data);
725                    var content = JSON.parse(json);
726                    if (callback) {
727                      return callback(content.status);
728                    }
729                  },
730                  function(error) {
731                    if (callback) {
732                      callback(error);
733                    } else {
734                      console.log(error);
735                    }
736                  });
737        },
738        getLastRebootTime: function() {
739          return $http({
740                   method: 'GET',
741                   url: DataService.getHost() +
742                       '/xyz/openbmc_project/state/bmc0/attr/LastRebootTime',
743                   withCredentials: true
744                 })
745              .then(function(response) {
746                return response.data;
747              });
748        },
749        hostPowerOn: function() {
750          var deferred = $q.defer();
751          $http({
752            method: 'PUT',
753            url: DataService.getHost() +
754                '/xyz/openbmc_project/state/host0/attr/RequestedHostTransition',
755            withCredentials: true,
756            data: JSON.stringify(
757                {'data': 'xyz.openbmc_project.State.Host.Transition.On'})
758          })
759              .then(
760                  function(response) {
761                    var json = JSON.stringify(response.data);
762                    var content = JSON.parse(json);
763                    deferred.resolve(content.status);
764                  },
765                  function(error) {
766                    console.log(error);
767                    deferred.reject(error);
768                  });
769          return deferred.promise;
770        },
771        hostPowerOff: function() {
772          var deferred = $q.defer();
773          $http({
774            method: 'PUT',
775            url: DataService.getHost() +
776                '/xyz/openbmc_project/state/host0/attr/RequestedHostTransition',
777            withCredentials: true,
778            data: JSON.stringify(
779                {'data': 'xyz.openbmc_project.State.Host.Transition.Off'})
780          })
781              .then(
782                  function(response) {
783                    var json = JSON.stringify(response.data);
784                    var content = JSON.parse(json);
785                    deferred.resolve(content.status);
786                  },
787                  function(error) {
788                    console.log(error);
789                    deferred.reject(error);
790                  });
791          return deferred.promise;
792        },
793        hostReboot: function() {
794          var deferred = $q.defer();
795          $http({
796            method: 'PUT',
797            url: DataService.getHost() +
798                '/xyz/openbmc_project/state/host0/attr/RequestedHostTransition',
799            withCredentials: true,
800            data: JSON.stringify(
801                {'data': 'xyz.openbmc_project.State.Host.Transition.Reboot'})
802          })
803              .then(
804                  function(response) {
805                    var json = JSON.stringify(response.data);
806                    var content = JSON.parse(json);
807                    deferred.resolve(content.status);
808                  },
809                  function(error) {
810                    console.log(error);
811                    deferred.reject(error);
812                  });
813
814          return deferred.promise;
815        },
816        hostShutdown: function(callback) {
817          $http({
818            method: 'POST',
819            url: DataService.getHost() + '/xyz/openbmc_project/state/host0',
820            withCredentials: true,
821            data: JSON.stringify({'data': []})
822          })
823              .then(
824                  function(response) {
825                    var json = JSON.stringify(response.data);
826                    var content = JSON.parse(json);
827                    if (callback) {
828                      return callback(content);
829                    }
830                  },
831                  function(error) {
832                    if (callback) {
833                      callback(error);
834                    } else {
835                      console.log(error);
836                    }
837                  });
838        },
839        getLastPowerTime: function() {
840          return $http({
841                   method: 'GET',
842                   url: DataService.getHost() +
843                       '/xyz/openbmc_project/state/chassis0/attr/LastStateChangeTime',
844                   withCredentials: true
845                 })
846              .then(function(response) {
847                return response.data;
848              });
849        },
850        getLogs: function() {
851          var deferred = $q.defer();
852          $http({
853            method: 'GET',
854            url: DataService.getHost() +
855                '/xyz/openbmc_project/logging/enumerate',
856            withCredentials: true
857          })
858              .then(
859                  function(response) {
860                    var json = JSON.stringify(response.data);
861                    var content = JSON.parse(json);
862                    var dataClone = JSON.parse(JSON.stringify(content.data));
863                    var data = [];
864                    var severityCode = '';
865                    var priority = '';
866                    var health = '';
867                    var relatedItems = [];
868                    var eventID = 'None';
869                    var description = 'None';
870
871                    for (var key in content.data) {
872                      if (content.data.hasOwnProperty(key) &&
873                          content.data[key].hasOwnProperty('Id')) {
874                        var severityFlags = {
875                          low: false,
876                          medium: false,
877                          high: false
878                        };
879                        severityCode =
880                            content.data[key].Severity.split('.').pop();
881                        priority =
882                            Constants.SEVERITY_TO_PRIORITY_MAP[severityCode];
883                        severityFlags[priority.toLowerCase()] = true;
884                        relatedItems = [];
885                        content.data[key].associations.forEach(function(item) {
886                          relatedItems.push(item[2]);
887                        });
888
889                        if (content.data[key].hasOwnProperty(['EventID'])) {
890                          eventID = content.data[key].EventID;
891                        }
892
893                        if (content.data[key].hasOwnProperty(['Description'])) {
894                          description = content.data[key].Description;
895                        }
896
897                        data.push(Object.assign(
898                            {
899                              path: key,
900                              copied: false,
901                              priority: priority,
902                              severity_code: severityCode,
903                              severity_flags: severityFlags,
904                              additional_data:
905                                  content.data[key].AdditionalData.join('\n'),
906                              type: content.data[key].Message,
907                              selected: false,
908                              search_text:
909                                  ('#' + content.data[key].Id + ' ' +
910                                   severityCode + ' ' +
911                                   content.data[key].Message + ' ' +
912                                   content.data[key].Severity + ' ' +
913                                   content.data[key].AdditionalData.join(' '))
914                                      .toLowerCase(),
915                              meta: false,
916                              confirm: false,
917                              related_items: relatedItems,
918                              eventID: eventID,
919                              description: description,
920                              data: {key: key, value: content.data[key]}
921                            },
922                            content.data[key]));
923                      }
924                    }
925                    deferred.resolve({data: data, original: dataClone});
926                  },
927                  function(error) {
928                    console.log(error);
929                    deferred.reject(error);
930                  });
931
932          return deferred.promise;
933        },
934        getSensorsInfo: function(url) {
935          return $http({
936                   method: 'GET',
937                   url: DataService.getHost() + url,
938                   withCredentials: true
939                 })
940              .then(
941                  function(response) {
942                    return response.data;
943                  },
944                  function(error) {
945                    console.log(JSON.stringify(error));
946                  });
947        },
948        getAllChassisCollection: function() {
949          var deferred = $q.defer();
950          var promises = [];
951          $http({
952            method: 'GET',
953            url: DataService.getHost() + '/redfish/v1/Chassis',
954            withCredentials: true
955          })
956              .then(
957                  function(response) {
958                    var members = response.data['Members'];
959                    angular.forEach(
960                        members,
961                        function(member) {
962                          promises.push($http({
963                                          method: 'GET',
964                                          url: DataService.getHost() +
965                                              member['@odata.id'],
966                                          withCredentials: true
967                                        }).then(function(res) {
968                            return res.data;
969                          }));
970                        }),
971                        $q.all(promises).then(
972                            function(results) {
973                              deferred.resolve(results);
974                            },
975                            function(errors) {
976                              deferred.reject(errors);
977                            });
978                  },
979                  function(error) {
980                    console.log(JSON.stringify(error));
981                  });
982          return deferred.promise;
983        },
984        getActivation: function(imageId) {
985          return $http({
986                   method: 'GET',
987                   url: DataService.getHost() +
988                       '/xyz/openbmc_project/software/' + imageId +
989                       '/attr/Activation',
990                   withCredentials: true
991                 })
992              .then(function(response) {
993                return response.data;
994              });
995        },
996        getFirmwares: function() {
997          var deferred = $q.defer();
998          $http({
999            method: 'GET',
1000            url: DataService.getHost() +
1001                '/xyz/openbmc_project/software/enumerate',
1002            withCredentials: true
1003          })
1004              .then(
1005                  function(response) {
1006                    var json = JSON.stringify(response.data);
1007                    var content = JSON.parse(json);
1008                    var data = [];
1009                    var isExtended = false;
1010                    var bmcActiveVersion = '';
1011                    var hostActiveVersion = '';
1012                    var imageType = '';
1013                    var extendedVersions = [];
1014                    var functionalImages = [];
1015
1016                    function getFormatedExtendedVersions(extendedVersion) {
1017                      var versions = [];
1018                      extendedVersion = extendedVersion.split(',');
1019
1020                      extendedVersion.forEach(function(item) {
1021                        var parts = item.split('-');
1022                        var numberIndex = 0;
1023                        for (var i = 0; i < parts.length; i++) {
1024                          if (/[0-9]/.test(parts[i])) {
1025                            numberIndex = i;
1026                            break;
1027                          }
1028                        }
1029                        var titlePart = parts.splice(0, numberIndex);
1030                        titlePart = titlePart.join('');
1031                        titlePart = titlePart[0].toUpperCase() +
1032                            titlePart.substr(1, titlePart.length);
1033                        var versionPart = parts.join('-');
1034                        versions.push({title: titlePart, version: versionPart});
1035                      });
1036
1037                      return versions;
1038                    }
1039
1040                    // Get the list of functional images so we can compare
1041                    // later if an image is functional
1042                    if (content.data[Constants.FIRMWARE.FUNCTIONAL_OBJPATH]) {
1043                      functionalImages =
1044                          content.data[Constants.FIRMWARE.FUNCTIONAL_OBJPATH]
1045                              .endpoints;
1046                    }
1047                    for (var key in content.data) {
1048                      if (content.data.hasOwnProperty(key) &&
1049                          content.data[key].hasOwnProperty('Version')) {
1050                        var activationStatus = '';
1051
1052                        // If the image is "Functional" use that for the
1053                        // activation status, else use the value of
1054                        // "Activation"
1055                        // github.com/openbmc/phosphor-dbus-interfaces/blob/master/xyz/openbmc_project/Software/Activation.interface.yaml
1056                        if (content.data[key].Activation) {
1057                          activationStatus =
1058                              content.data[key].Activation.split('.').pop();
1059                        }
1060
1061                        if (functionalImages.includes(key)) {
1062                          activationStatus = 'Functional';
1063                        }
1064
1065                        imageType = content.data[key].Purpose.split('.').pop();
1066                        isExtended = content.data[key].hasOwnProperty(
1067                                         'ExtendedVersion') &&
1068                            content.data[key].ExtendedVersion != '';
1069                        if (isExtended) {
1070                          extendedVersions = getFormatedExtendedVersions(
1071                              content.data[key].ExtendedVersion);
1072                        }
1073                        data.push(Object.assign(
1074                            {
1075                              path: key,
1076                              activationStatus: activationStatus,
1077                              imageId: key.split('/').pop(),
1078                              imageType: imageType,
1079                              isExtended: isExtended,
1080                              extended:
1081                                  {show: false, versions: extendedVersions},
1082                              data: {key: key, value: content.data[key]}
1083                            },
1084                            content.data[key]));
1085
1086                        if (activationStatus == 'Functional' &&
1087                            imageType == 'BMC') {
1088                          bmcActiveVersion = content.data[key].Version;
1089                        }
1090
1091                        if (activationStatus == 'Functional' &&
1092                            imageType == 'Host') {
1093                          hostActiveVersion = content.data[key].Version;
1094                        }
1095                      }
1096                    }
1097
1098                    deferred.resolve({
1099                      data: data,
1100                      bmcActiveVersion: bmcActiveVersion,
1101                      hostActiveVersion: hostActiveVersion
1102                    });
1103                  },
1104                  function(error) {
1105                    console.log(error);
1106                    deferred.reject(error);
1107                  });
1108
1109          return deferred.promise;
1110        },
1111        changePriority: function(imageId, priority) {
1112          return $http({
1113                   method: 'PUT',
1114                   url: DataService.getHost() +
1115                       '/xyz/openbmc_project/software/' + imageId +
1116                       '/attr/Priority',
1117                   withCredentials: true,
1118                   data: JSON.stringify({'data': priority})
1119                 })
1120              .then(function(response) {
1121                return response.data;
1122              });
1123        },
1124        deleteImage: function(imageId) {
1125          return $http({
1126                   method: 'POST',
1127                   url: DataService.getHost() +
1128                       '/xyz/openbmc_project/software/' + imageId +
1129                       '/action/Delete',
1130                   withCredentials: true,
1131                   data: JSON.stringify({'data': []})
1132                 })
1133              .then(function(response) {
1134                return response.data;
1135              });
1136        },
1137        activateImage: function(imageId) {
1138          return $http({
1139                   method: 'PUT',
1140                   url: DataService.getHost() +
1141                       '/xyz/openbmc_project/software/' + imageId +
1142                       '/attr/RequestedActivation',
1143                   withCredentials: true,
1144                   data: JSON.stringify(
1145                       {'data': Constants.FIRMWARE.ACTIVATE_FIRMWARE})
1146                 })
1147              .then(function(response) {
1148                return response.data;
1149              });
1150        },
1151        uploadImage: function(file) {
1152          return $http({
1153                   method: 'POST',
1154                   timeout: 5 * 60 * 1000,
1155                   url: DataService.getHost() + '/upload/image',
1156                   // Overwrite the default 'application/json' Content-Type
1157                   headers: {'Content-Type': 'application/octet-stream'},
1158                   withCredentials: true,
1159                   data: file
1160                 })
1161              .then(function(response) {
1162                return response.data;
1163              });
1164        },
1165        downloadImage: function(host, filename) {
1166          return $http({
1167                   method: 'POST',
1168                   url: DataService.getHost() +
1169                       '/xyz/openbmc_project/software/action/DownloadViaTFTP',
1170                   withCredentials: true,
1171                   data: JSON.stringify({'data': [filename, host]}),
1172                   responseType: 'arraybuffer'
1173                 })
1174              .then(function(response) {
1175                return response.data;
1176              });
1177        },
1178        getServerInfo: function() {
1179          // TODO: openbmc/openbmc#3117 Need a way via REST to get
1180          // interfaces so we can get the system object(s) by the looking
1181          // for the system interface.
1182          return $http({
1183                   method: 'GET',
1184                   url: DataService.getHost() +
1185                       '/xyz/openbmc_project/inventory/system',
1186                   withCredentials: true
1187                 })
1188              .then(function(response) {
1189                return response.data;
1190              });
1191        },
1192        getBMCTime: function() {
1193          return $http({
1194                   method: 'GET',
1195                   url: DataService.getHost() + '/xyz/openbmc_project/time/bmc',
1196                   withCredentials: true
1197                 })
1198              .then(function(response) {
1199                return response.data;
1200              });
1201        },
1202        getTime: function() {
1203          return $http({
1204                   method: 'GET',
1205                   url: DataService.getHost() +
1206                       '/xyz/openbmc_project/time/enumerate',
1207                   withCredentials: true
1208                 })
1209              .then(function(response) {
1210                return response.data;
1211              });
1212        },
1213        // Even though NTPServers is a network interface specific path
1214        // (e.g. /xyz/openbmc_project/network/eth0/attr/NTPServers) it acts
1215        // like a global setting. Just use eth0 for setting and getting the
1216        // NTP Servers until it is moved to a non-network interface specific
1217        // path like it is in Redfish. TODO: openbmc/phosphor-time-manager#4
1218        getNTPServers: function() {
1219          return $http({
1220                   method: 'GET',
1221                   url: DataService.getHost() +
1222                       '/xyz/openbmc_project/network/eth0/attr/NTPServers',
1223                   withCredentials: true
1224                 })
1225              .then(function(response) {
1226                return response.data;
1227              });
1228        },
1229        setNTPServers: function(ntpServers) {
1230          return $http({
1231                   method: 'PUT',
1232                   url: DataService.getHost() +
1233                       '/xyz/openbmc_project/network/eth0/attr/NTPServers',
1234                   withCredentials: true,
1235                   data: JSON.stringify({'data': ntpServers})
1236                 })
1237              .then(function(response) {
1238                return response.data;
1239              });
1240        },
1241        setTimeMode: function(timeMode) {
1242          return $http({
1243                   method: 'PUT',
1244                   url: DataService.getHost() +
1245                       '/xyz/openbmc_project/time/sync_method/attr/TimeSyncMethod',
1246                   withCredentials: true,
1247                   data: JSON.stringify({'data': timeMode})
1248                 })
1249              .then(function(response) {
1250                return response.data;
1251              });
1252        },
1253        setTimeOwner: function(timeOwner) {
1254          return $http({
1255                   method: 'PUT',
1256                   url: DataService.getHost() +
1257                       '/xyz/openbmc_project/time/owner/attr/TimeOwner',
1258                   withCredentials: true,
1259                   data: JSON.stringify({'data': timeOwner})
1260                 })
1261              .then(function(response) {
1262                return response.data;
1263              });
1264        },
1265        setBMCTime: function(time) {
1266          return $http({
1267                   method: 'PUT',
1268                   url: DataService.getHost() +
1269                       '/xyz/openbmc_project/time/bmc/attr/Elapsed',
1270                   withCredentials: true,
1271                   data: JSON.stringify({'data': time})
1272                 })
1273              .then(function(response) {
1274                return response.data;
1275              });
1276        },
1277        setHostTime: function(time) {
1278          return $http({
1279                   method: 'PUT',
1280                   url: DataService.getHost() +
1281                       '/xyz/openbmc_project/time/host/attr/Elapsed',
1282                   withCredentials: true,
1283                   data: JSON.stringify({'data': time})
1284                 })
1285              .then(function(response) {
1286                return response.data;
1287              });
1288        },
1289        getHardwares: function(callback) {
1290          $http({
1291            method: 'GET',
1292            url: DataService.getHost() +
1293                '/xyz/openbmc_project/inventory/enumerate',
1294            withCredentials: true
1295          }).then(function(response) {
1296            var json = JSON.stringify(response.data);
1297            var content = JSON.parse(json);
1298            var hardwareData = [];
1299            var keyIndexMap = {};
1300            var title = '';
1301            var depth = '';
1302            var data = [];
1303            var searchText = '';
1304            var componentIndex = -1;
1305            var parent = '';
1306
1307            function isSubComponent(key) {
1308              for (var i = 0; i < Constants.HARDWARE.parent_components.length;
1309                   i++) {
1310                if (key.split(Constants.HARDWARE.parent_components[i]).length ==
1311                    2)
1312                  return true;
1313              }
1314
1315              return false;
1316            }
1317
1318            function titlelize(title) {
1319              title = title.replace(/([A-Z0-9]+)/g, ' $1').replace(/^\s+/, '');
1320              for (var i = 0; i < Constants.HARDWARE.uppercase_titles.length;
1321                   i++) {
1322                if (title.toLowerCase().indexOf(
1323                        (Constants.HARDWARE.uppercase_titles[i] + ' ')) > -1) {
1324                  return title.toUpperCase();
1325                }
1326              }
1327
1328              return title;
1329            }
1330
1331            function camelcaseToLabel(obj) {
1332              var transformed = [], label = '', value = '';
1333              for (var key in obj) {
1334                label = key.replace(/([A-Z0-9]+)/g, ' $1').replace(/^\s+/, '');
1335                if (obj[key] !== '') {
1336                  value = obj[key];
1337                  if (value == 1 || value == 0) {
1338                    value = (value == 1) ? 'Yes' : 'No';
1339                  }
1340                  transformed.push({key: label, value: value});
1341                }
1342              }
1343
1344              return transformed;
1345            }
1346
1347            function determineParent(key) {
1348              var levels = key.split('/');
1349              levels.pop();
1350              return levels.join('/');
1351            }
1352
1353            function getSearchText(data) {
1354              var searchText = '';
1355              for (var i = 0; i < data.length; i++) {
1356                searchText += ' ' + data[i].key + ' ' + data[i].value;
1357              }
1358
1359              return searchText;
1360            }
1361
1362            for (var key in content.data) {
1363              if (content.data.hasOwnProperty(key) &&
1364                  key.indexOf(Constants.HARDWARE.component_key_filter) == 0) {
1365                data = camelcaseToLabel(content.data[key]);
1366                searchText = getSearchText(data);
1367                title = key.split('/').pop();
1368                // All and only associations have the property "endpoints".
1369                // We don't want to show associations on the hardware page.
1370                // Example: An association from the BMC inventory item to the
1371                // BMC firmware images.
1372                if (content.data[key].hasOwnProperty('endpoints')) {
1373                  continue;
1374                }
1375
1376                title = titlelize(title);
1377                // e.g. /xyz/openbmc_project/inventory/system and
1378                // /xyz/openbmc_project/inventory/system/chassis are depths of 5
1379                // and 6.
1380                depth = key.split('/').length;
1381                parent = determineParent(key);
1382
1383                if (!isSubComponent(key)) {
1384                  hardwareData.push(Object.assign(
1385                      {
1386                        path: key,
1387                        title: title,
1388                        depth: depth,
1389                        parent: parent,
1390                        selected: false,
1391                        expanded: false,
1392                        search_text: title.toLowerCase() + ' ' +
1393                            searchText.toLowerCase(),
1394                        sub_components: [],
1395                        original_data: {key: key, value: content.data[key]}
1396                      },
1397                      {items: data}));
1398
1399                  keyIndexMap[key] = hardwareData.length - 1;
1400                } else {
1401                  parent = determineParent(key)
1402                  componentIndex = keyIndexMap[parent];
1403                  data = content.data[key];
1404                  data.title = title;
1405                  hardwareData[componentIndex].sub_components.push(data);
1406                  hardwareData[componentIndex].search_text +=
1407                      ' ' + title.toLowerCase();
1408
1409                  // Sort the subcomponents alphanumeric so they are displayed
1410                  // on the inventory page in order (e.g. core 0, core 1, core
1411                  // 2, ... core 12, core 13)
1412                  hardwareData[componentIndex].sub_components.sort(function(
1413                      a, b) {
1414                    return a.title.localeCompare(
1415                        b.title, 'en', {numeric: true});
1416                  });
1417                }
1418              }
1419            }
1420            // First, order the components by depth and then place the child
1421            // components beneath their parent component alphanumerically. Can
1422            // be removed with completion of
1423            // https://github.com/openbmc/openbmc/issues/3401
1424            // TODO: Remove this once implemented in back end
1425            hardwareData.sort(function(a, b) {
1426              if (a.depth < b.depth) return -1;
1427              if (a.depth > b.depth) return 1;
1428              return b.title.localeCompare(a.title, 'en', {numeric: true});
1429            });
1430
1431            var orderedComponents = [];
1432
1433            for (var i = 0; i < hardwareData.length; i++) {
1434              if (!keyIndexMap[hardwareData[i].parent]) {
1435                orderedComponents.push(hardwareData[i]);
1436              } else {
1437                for (var j = 0; j < orderedComponents.length; j++) {
1438                  if (orderedComponents[j].path === hardwareData[i].parent) {
1439                    var child = hardwareData[i];
1440                    orderedComponents.splice(j + 1, 0, child);
1441                  }
1442                }
1443              }
1444            }
1445
1446            if (callback) {
1447              callback(orderedComponents, content.data);
1448            } else {
1449              return {data: orderedComponents, original_data: content.data};
1450            }
1451          });
1452        },
1453        deleteLogs: function(logs) {
1454          var defer = $q.defer();
1455          var promises = [];
1456
1457          function finished() {
1458            defer.resolve();
1459          }
1460
1461          logs.forEach(function(item) {
1462            promises.push($http({
1463              method: 'POST',
1464              url: DataService.getHost() +
1465                  '/xyz/openbmc_project/logging/entry/' + item.Id +
1466                  '/action/Delete',
1467              withCredentials: true,
1468              data: JSON.stringify({'data': []})
1469            }));
1470          });
1471
1472          $q.all(promises).then(finished);
1473
1474          return defer.promise;
1475        },
1476        resolveLogs: function(logs) {
1477          var promises = [];
1478
1479          logs.forEach(function(item) {
1480            promises.push($http({
1481              method: 'PUT',
1482              url: DataService.getHost() +
1483                  '/xyz/openbmc_project/logging/entry/' + item.Id +
1484                  '/attr/Resolved',
1485              withCredentials: true,
1486              data: JSON.stringify({'data': true})
1487            }));
1488          });
1489          return $q.all(promises);
1490        },
1491        getPowerConsumption: function() {
1492          return $http({
1493                   method: 'GET',
1494                   url: DataService.getHost() +
1495                       '/xyz/openbmc_project/sensors/power/total_power',
1496                   withCredentials: true
1497                 })
1498              .then(
1499                  function(response) {
1500                    var json = JSON.stringify(response.data);
1501                    var content = JSON.parse(json);
1502
1503                    return getScaledValue(
1504                               content.data.Value, content.data.Scale) +
1505                        ' ' +
1506                        Constants.POWER_CONSUMPTION_TEXT[content.data.Unit];
1507                  },
1508                  function(error) {
1509                    if ('Not Found' == error.statusText) {
1510                      return Constants.POWER_CONSUMPTION_TEXT.notavailable;
1511                    } else {
1512                      throw error;
1513                    }
1514                  });
1515        },
1516        getPowerCap: function() {
1517          return $http({
1518                   method: 'GET',
1519                   url: DataService.getHost() +
1520                       '/xyz/openbmc_project/control/host0/power_cap',
1521                   withCredentials: true
1522                 })
1523              .then(function(response) {
1524                return response.data;
1525              });
1526        },
1527        setPowerCapEnable: function(powerCapEnable) {
1528          return $http({
1529                   method: 'PUT',
1530                   url: DataService.getHost() +
1531                       '/xyz/openbmc_project/control/host0/power_cap/attr/PowerCapEnable',
1532                   withCredentials: true,
1533                   data: JSON.stringify({'data': powerCapEnable})
1534                 })
1535              .then(function(response) {
1536                return response.data;
1537              });
1538        },
1539        setPowerCap: function(powerCap) {
1540          return $http({
1541                   method: 'PUT',
1542                   url: DataService.getHost() +
1543                       '/xyz/openbmc_project/control/host0/power_cap/attr/PowerCap',
1544                   withCredentials: true,
1545                   data: JSON.stringify({'data': powerCap})
1546                 })
1547              .then(function(response) {
1548                return response.data;
1549              });
1550        },
1551        setHostname: function(hostname) {
1552          return $http({
1553                   method: 'PUT',
1554                   url: DataService.getHost() +
1555                       '/xyz/openbmc_project/network/config/attr/HostName',
1556                   withCredentials: true,
1557                   data: JSON.stringify({'data': hostname})
1558                 })
1559              .then(function(response) {
1560                return response.data;
1561              });
1562        },
1563      };
1564      return SERVICE;
1565    }
1566  ]);
1567})(window.angular);
1568