Front End

목차

  • 개요
  • Angular JS
  • Tools
  • Swagger 
  • CSS

개요

NSight-Common

- NSight-API 호출을 위한 모듈

- Angular JS 프레임 워크 생성

 

Angular JS

  • 2009년 Misko Hevery와 Adam Abrons 에 의해 개발된 MVC 웹프레임워크
  • 간편한 데이터 바인딩을 통해 뷰 업데이트가 쉽다.
  • 코드 패턴이 동일해 개인간 차이에 따른 결과물의 차이가 적다. 코드량이 감소한다.
  • 기능적인 분리가 명확해 협업이 쉽다.
  • 유지보수가 쉽다, 개발속도가 빠르다.

 

Angular JS

Angular JS

  • One-Way Data Binding: 대부분 template System은 템플릿과 데이터를 조합하고 뷰를 구성하는 형태이다. 한번 구성된 뒤에는 데이터가 업데이트되더라도 자동으로 뷰에 적용되진 않는다. 마찬가지로 반대로 사용자에의해 뷰에서 변경이 있어도 데이터에 반영되지 못한다. 

 

  • Two-Way Data Binding: Angular에서는 기본으로 템플릿과 데이터로 뷰를 구성한 뒤에도 데이터와 뷰가 서로의 변경에 따라 업데이트가 되는 기능을 제공한다.

 

Angular JS

  • ng-model="name": 데이터 바인딩을 위해 사용되는 지시자, 값으로 지정한 'name'은 모델의 이름으로 사용됨

 

  • {{name}} : 데이터 출력을 위한 템플릿 표현식, ng-model과 바인딩되어 처리됨

 

Angular JS

  • Controller : scope의 상태를 초기화 하거나 동작을 정의한다.

Angular JS

  • scope:  view 에 표시된 모델을 controller 에서 제어할수 있도록 해준다.
                 

 

Angular JS

  • scope:  controller 마다 고유의 scope 영역을 지니며 계층구조를 가질수 있다.
                 angular App 에는 하나의 root scope 가 있으며 모든 scope 의 최상위에 있다.
                 

 

Angular JS

  • Service: 싱글톤 객체로 생성되며 뷰와 독립적인 비지니스 로직을 구성한다.
                   DI 를 통해 어떤 App 에서든 사용할수 있다.

 

Angular JS

  • directive: custom tag 를 만들 수 있다.
                      tag의 element, attribute, class 단위로 적용 가능하다.
                      html template 도 적용 가능

Angular JS

  • Nsight Mobile UI

Angular JS

  • Module: Controller, Service, Directive 등으로 구성된 하나의 어플리케이션을 뜻한다.
                   Module은 다른 Module에 의해 사용될 수 있다.

 

Angular JS

  • Jasmine : javascript 를 테스트 할수 있게 하는 프레임워크로 Angular JS 에서 Unit Test가능하게 한다.

 

angular.module('app', [])
.controller('PasswordController', function PasswordController($scope) {
  $scope.password = '';
  $scope.grade = function() {
    var size = $scope.password.length;
    if (size > 8) {
      $scope.strength = 'strong';
    } else if (size > 3) {
      $scope.strength = 'medium';
    } else {
      $scope.strength = 'weak';
    }
  };
});
describe('PasswordController', function() {
  beforeEach(module('app'));

  var $controller;

  beforeEach(inject(function(_$controller_){
    // The injector unwraps the underscores (_) from around the parameter names when matching
    $controller = _$controller_;
  }));

  describe('$scope.grade', function() {
    it('sets the strength to "strong" if the password length is >8 chars', function() {
      var $scope = {};
      var controller = $controller('PasswordController', { $scope: $scope });
      $scope.password = 'longerthaneightchars';
      $scope.grade();
      expect($scope.strength).toEqual('strong');
    });
  });
});

Tools

NPM ( Node Package Manager )

- Linux의 rpm처럼 repository에서 해당 모듈을 읽어 설치를 해주며 maven의 pom.xml처럼 pacakag.json 파일에 module간의 dependency에 따라서 모듈을 같이 설치한다. 중첩된 의존성을 지원함.

- 주로 빌드, 테스트, 최적화 도구를 설치할 때 이용함

Bower

- npm 처럼 동작하며 package.json과 동작이 비슷한 bower.json 파일이 존재한다. 중첩된 의존성을 지원하지 않는다.

- 주로 어플리케이션에서 쓰일 모듈들을 설치할때 이용함

Tools

NPM ( Node Package Manager ) 

 - pacakage.json

{
  "name": "nsight-common",
  "dependencies": {
    "gulp-sass": "^2.0.4",
    "is_js": "^0.7.4",
    "lodash": "^3.10.1",
    "moment": "^2.10.6",
    "node-sass": "^3.3.3",
    "restangular": "^1.5.1"
  },
  "scripts": {
    "watch": "gulp serve",
    "docs": "cd docs && gulp docs:serve",
    "test": "gulp test",
    "dist": "gulp test && gulp && cd docs && gulp"
  },
  "devDependencies": {
    "babel-core": "^5.8.22",
    "babel-loader": "^5.3.2",
    "browser-sync": "~1.7.1",
    "chalk": "~0.5.1",
    "conventional-changelog": "0.0.17",
    "del": "~0.1.3",
    "gulp": "~3.9.0",
    "gulp-angular-filesort": "~1.0.4",
    "gulp-angular-templatecache": "~1.4.2",
    "gulp-autoprefixer": "~2.0.0",
    "gulp-concat": "^2.4.3",
    "gulp-consolidate": "~0.1.2",
    "gulp-csso": "~0.2.9",
    "gulp-filter": "~1.0.2",
    "gulp-flatten": "~0.0.4",
    "gulp-inject": "~1.0.2",
    "gulp-jshint": "~1.9.0",
    "gulp-karma": "~0.0.4",
    "gulp-load-plugins": "~0.7.1",
    "gulp-minify-html": "~0.1.7",
    "gulp-ng-annotate": "^0.5.2",
    "gulp-ngdocs": "^0.2.10",
    "gulp-protractor": "~0.0.11",
    "gulp-rename": "~1.2.0",
    "gulp-replace": "~0.5.0",
    "gulp-rev": "~2.0.1",
    "gulp-rev-replace": "~0.3.1",
    "gulp-sass": "^2.0.4",
    "gulp-size": "~1.1.0",
    "gulp-uglify": "~1.0.1",
    "gulp-useref": "~1.0.2",
    "gulp-util": "^3.0.6",
    "gulp-webpack": "^1.5.0",
    "http-proxy": "~1.7.0",
    "jshint": "^2.8.0",
    "jshint-loader": "^0.8.3",
    "jshint-stylish": "~1.0.0",
    "karma-coverage": "^0.2.7",
    "karma-jasmine": "~0.3.1",
    "karma-phantomjs-launcher": "~0.1.4",
    "lodash": "^3.10.1",
    "main-bower-files": "~2.4.0",
    "protractor": "~1.4.0",
    "q": "^1.4.1",
    "request": "^2.65.0",
    "require-dir": "~0.1.0",
    "run-sequence": "^1.1.0",
    "swagger-js-codegen": "^1.1.5",
    "uglify-save-license": "~0.4.1",
    "webpack": "^1.11.0",
    "wiredep": "~2.2.0",
    "wrench": "^1.5.8",
    "pre-commit": "^1.1.2"
  },
  "pre-commit": [
    "test"
  ],
  "engines": {
    "node": ">=0.10.0"
  }
}

Tools

Bower

 - bower.json

{
  "name": "frontPush",
  "version": "0.0.0",
  "dependencies": {
    "angular-animate": "~1.4.2",
    "angular-cookies": "~1.4.2",
    "angular-touch": "~1.4.2",
    "angular-sanitize": "~1.4.2",
    "angular-messages": "~1.4.2",
    "angular-aria": "~1.4.2",
    "jquery": "~1.11.3",
    "restangular": "~1.5.1",
    "angular-ui-router": "~0.2.15",
    "bootstrap": "~3.3.5",
    "angular-bootstrap": "~0.13.4",
    "malarkey": "yuanqing/malarkey#~1.3.1",
    "angular-toastr": "~1.5.0",
    "moment": "~2.10.6",
    "animate.css": "~3.4.0",
    "angular": "~1.4.2",
    "angular-smart-table": "~2.1.4",
    "rdash-ui": "~1.0.1",
    "angular-swagger": "~0.0.5",
    "angular-swagger-ui": "~0.2.7",
    "nsight-common": "git+http://yobi.navercorp.com/IT_DEV_Front/nsight-common#8cee0a898667ee784cc3f55612b89e9de3993fbf"
  },
  "devDependencies": {
    "angular-mocks": "~1.4.2"
  },
  "overrides": {
    "bootstrap": {
      "main": [
        "dist/css/bootstrap.css",
        "dist/fonts/glyphicons-halflings-regular.eot",
        "dist/fonts/glyphicons-halflings-regular.svg",
        "dist/fonts/glyphicons-halflings-regular.ttf",
        "dist/fonts/glyphicons-halflings-regular.woff",
        "dist/fonts/glyphicons-halflings-regular.woff2"
      ]
    }
  },
  "resolutions": {
    "jquery": "~1.11.3",
    "angular": "~1.4.2"
  }
}

Tools

Yeoman

- bootstrap, angular route 등 기본적으로 많이 쓰이는 모듈들을 개발자가 따로 구성할 필요 없이 자동으로 구성 할수 있도록 도와준다.

   

  

Tools

Tools

Gulp

  • Maven, Ant 와 같은 빌드 툴
  • 코드 오류 확인, nodejs를 이용한 로컬서버 실행, 난독화 등 가능
gulp.src('./client/templates/*.jade')
  .pipe(jade())
  .pipe(gulp.dest('./build/templates'))
  .pipe(minify())
  .pipe(gulp.dest('./build/minified_templates'));
  • src() : 작업 대상 파일
  • pipe(func()) : 작업 지정
  • dest() : 작업 결과 파일을 쓸 곳
gulp.task('mytask', ['array', 'of', 'task', 'names'], function() {
  // Do stuff
});
  • task() : 특정 작업들을 하나의 명령어로 묶을수 있다

Tools

Dgeni 

  • 문서 자동 생성 도구

/**
 * @ngdoc service
 * @name $nsightUser
 * @module nsightUser
 *
 * @description
 * User API 연동을 위한 서비스
 */

var serviceName = '$nsightUser';
class UserFactory{
  constructor($log,
              $q,
              _,
              Restangular,
              NS_CONFIG)
  {
    'ngInject';
    this._ = _;
    this.$log = $log;
    this.$q = $q;
    this.Restangular = Restangular;
    this.NS_CONFIG = NS_CONFIG;
  }


  /**
   * @ngdoc service
   * @name getUserByEmpNo
   * @module nsightUser
   *
   * @description
   * 사번으로 해당 직원 정보 조회
   *
   * @param {object} params
   *
   * ## Parameter
   * | Key   | Require | Default | Description               |
   * |:------|:-------:|:-------:|:--------------------------|
   * | empNo |    O    |    X    | 사번                      |
   *
   * @example
   * <example module="app">
   * <file name="index.html">
   * <h2>JavaScript</h2>
   * <pre>{{ result | nsPrettyJson}}</pre>
   * </file>
   * <file name="app.js">
   * angular.module('app', [
   *  'nsightCommon'
   * ]).config(function($logProvider) {
       *   $logProvider.debugEnabled(false);
       * }).run(function($rootScope, is, $nsightUser) {
       *   $nsightUser.getUserByEmpNo({
       *    empNo: 'NB10343'
       *   }).then(
       *     // Success
       *     function (data) {
       *      if (is.array(data)) {
       *         // Parsing data
       *         $rootScope.result = data;
       *       } else {
       *         $rootScope.result = '데이터가 없습니다.';
       *       }
       *     },
       *     // Error
       *     function () {
       *       $rootScope.result = '데이터를 가져오는 중 오류가 발생했습니다.';
       *     }
       *   );
       * });
   * </file>
   * </example>
   *
   * ## Response
   * <pre>
   * [
   *  {
       *    "empNo": "NB90***",
       *    "empNm": "김우*",
       *    "cphNo": "010729*****",
       *    "email": "nb90*****.com",
       *    "deptCd": "ETCNB",
       *    "nttlNm": "A1410020076"
       *  }
   * ]
   * </pre>
   */
  getUserByEmpNo(params) {
    var empNo = params.empNo;
    delete params.empNo;
    var _this = this;
    return this.Restangular.allUrl('employees' , this.NS_CONFIG.apiUrl)
      .one('employee', empNo)
      .get(_this._.extend({}, params));
  }

Tools

Dgeni 

  • 문서 자동 생성 도구

Swagger

  • API 문서를 정의하면 Server, Client 소스를 생성할수 있다.

Swagger

  • Server : Annotation 기반으로 API Doc 작성

@RestController
@Api(value = "/users", description = "User API")
@RequestMapping("/users")
public class UserController {

    @Autowired
    UserManager userManager;

    @ApiOperation(value = "select User", notes = "사용자 정보를 가져온다.")
    @RequestMapping(method = RequestMethod.GET)
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "사용자 정보", response = User.class),
            @ApiResponse(code = 404, message = "페이지가 없음"),
            @ApiResponse(code = 500, message = "서버 에러", response = com.nbp.dm.Error.class)}
    )
    public List<User> selectUsers(
            @ApiParam(value = "사용자 이름") @RequestParam(required = false) String empNm
            , @ApiParam(value = "사용자 사번") @RequestParam(required = false) String empNo
            , @ApiParam(value = "사용자 OS") @RequestParam(required = false) String type) {

        return userManager.selectUsers(empNm, empNo, type);
    }

Swagger

  • Client: Angular-client generator를 이용하여 Client API Code 생성 가능
                Server API - Client API - API Doc 한번에 생성 할수 있다.
                mustache 템플릿을 이용하여 생성됨
/**
 * @ngdoc method
 * @name $pushCommon#{{&methodName}}
 * @methodOf $pushCommon

 * @param {object} params
    *
    * ## Parameter
    * | Key   | Require | Default | Description               |
    * |:------|:-------:|:-------:|:--------------------------|
{{#parameters}}

{{#required}}
    {{^isSingleton}} * | {{&camelCaseName}} | O | X | {{&description}}{{/isSingleton}} |
{{/required}}
{{^required}}
    {{^isSingleton}} * | {{&camelCaseName}} | X | X | {{&description}}{{/isSingleton}} |
{{/required}}

{{/parameters}}

 * @returns {Object} {{&summary}} promise 객체를 리턴한다.
 * 
 */

 {{&className}}.prototype.{{&methodName}} = function(parameters){
    if(parameters === undefined) {
        parameters = {};
    }
    var deferred = {{#isNode}}Q{{/isNode}}{{^isNode}}$q{{/isNode}}.defer();
    
    var domain = this.domain;
    var path = '{{&path}}';
    
    var body;
    var queryParameters = {};
    var headers = {};
    var form = {};

    {{#isSecure}}
        if (this.token.isQuery) {
            queryParameters[this.token.headerOrQueryName] = this.token.value;
        } else if (this.token.headerOrQueryName) {
            headers[this.token.headerOrQueryName] = this.token.value;    
        } else {
            headers['Authorization'] = 'Bearer ' + this.token.value;
        }
    {{/isSecure}}

    {{#parameters}}
       
        {{#isQueryParameter}}
            {{#isSingleton}}
                queryParameters['{{&name}}'] = '{{&singleton}}';
            {{/isSingleton}}
            {{^isSingleton}}
                {{#isPatternType}}
                    Object.keys(parameters).forEach(function(parameterName) {
                        if(new RegExp('{{&pattern}}').test(parameterName)){
                            queryParameters[parameterName] = parameters[parameterName];
                        }
                    });
                {{/isPatternType}}
                {{^isPatternType}}
                if(parameters['{{&camelCaseName}}'] !== undefined){
                    queryParameters['{{&name}}'] = parameters['{{&camelCaseName}}'];
                }
                {{/isPatternType}}
            {{/isSingleton}}
        {{/isQueryParameter}}
        
        {{#isPathParameter}}
            path = path.replace('{{=<% %>=}}{<%&name%>}<%={{ }}=%>', parameters['{{&camelCaseName}}']);
        {{/isPathParameter}}
        
        {{#isHeaderParameter}}
            {{#isSingleton}}
                headers['{{&name}}'] = '{{&singleton}}';
            {{/isSingleton}}
            {{^isSingleton}}
                if(parameters['{{&camelCaseName}}'] !== undefined){
                    headers['{{&name}}'] = parameters['{{&camelCaseName}}'];
                }
            {{/isSingleton}}
        {{/isHeaderParameter}}
        
        {{#isBodyParameter}}
            if(parameters['{{&camelCaseName}}'] !== undefined){
                body = parameters['{{&camelCaseName}}'];
            }
        {{/isBodyParameter}}

         {{#isFormParameter}}
            {{#isSingleton}}
                form['{{&name}}'] = '{{&singleton}}';
            {{/isSingleton}}
            {{^isSingleton}}
                if(parameters['{{&camelCaseName}}'] !== undefined){
                    form['{{&name}}'] = parameters['{{&camelCaseName}}'];
                }
            {{/isSingleton}}
        {{/isFormParameter}}

        {{#required}}
        if(parameters['{{&camelCaseName}}'] === undefined){
            deferred.reject(new Error('Missing required {{¶mType}} parameter: {{&camelCaseName}}'));
            return deferred.promise;
        }
        {{/required}}
 
    {{/parameters}}
    
    if(parameters.$queryParameters) {
        Object.keys(parameters.$queryParameters)
        .forEach(function(parameterName){
            var parameter = parameters.$queryParameters[parameterName];
            queryParameters[parameterName] = parameter;
        });
    }

    {{> request}}
    
    return deferred.promise; 
 };

/*jshint -W069 */
/*global angular:false */
angular.module('nsightCommon')
    .factory('$nsightCommonSwagger', ['$q', '$http', '$rootScope', function($q, $http, $rootScope) {
        'use strict';

        /**
         * @ngdoc service
           @name  $pushCommon
         * @module pushCommon
         *
         * @description
         * description
         */
        var $nsightCommonSwagger = (function() {
            function $nsightCommonSwagger(options, cache) {
                var domain = (typeof options === 'object') ? options.domain : options;
                this.domain = typeof(domain) === 'string' ? domain : '';
                if (this.domain.length === 0) {
                    throw new Error('Domain parameter must be specified as a string.');
                }
                cache = cache || ((typeof options === 'object') ? options.cache : cache);
                this.cache = cache;
            }

            $nsightCommonSwagger.prototype.$on = function($scope, path, handler) {
                var url = domain + path;
                $scope.$on(url, function() {
                    handler();
                });
                return this;
            };

            $nsightCommonSwagger.prototype.$broadcast = function(path) {
                var url = domain + path;
                //cache.remove(url);
                $rootScope.$broadcast(url);
                return this;
            };

            $nsightCommonSwagger.transformRequest = function(obj) {
                var str = [];
                for (var p in obj) {
                    var val = obj[p];
                    if (angular.isArray(val)) {
                        val.forEach(function(val) {
                            str.push(encodeURIComponent(p) + "=" + encodeURIComponent(val));
                        });
                    } else {
                        str.push(encodeURIComponent(p) + "=" + encodeURIComponent(val));
                    }
                }
                return str.join("&");
            };

            /**
             * @ngdoc method
             * @name $pushCommon#selectAllLogsUsingGET
             * @methodOf $pushCommon


             * @param {object} params
                *
                * ## Parameter
                * | Key   | Require | Default | Description               |
                * |:------|:-------:|:-------:|:--------------------------|

                 * | rows | O | X | 한 페이지에 데이터 갯수 |


                 * | page | O | X | 페이지 번호 |


                 * | startTime | X | X | 시작시간 |


                 * | endTime | X | X | 끝시간 |


                 * | senderType | X | X | 전송 타입 |


                 * | solutionType | X | X | 전송한 솔루션 |


                 * | message | X | X | 메세지 |


                 * | from | X | X | 전화번호 |


             * @returns {Object} Log를 가져옵니다. promise 객체를 리턴한다.
             *
             */

            $nsightCommonSwagger.prototype.selectAllLogsUsingGET = function(parameters) {
                if (parameters === undefined) {
                    parameters = {};
                }
                var deferred = $q.defer();

                var domain = this.domain;
                var path = '/log';

                var body;
                var queryParameters = {};
                var headers = {};
                var form = {};

                if (parameters['rows'] !== undefined) {
                    queryParameters['rows'] = parameters['rows'];
                }

                if (parameters['rows'] === undefined) {
                    deferred.reject(new Error('Missing required  parameter: rows'));
                    return deferred.promise;
                }

                if (parameters['page'] !== undefined) {
                    queryParameters['page'] = parameters['page'];
                }

                if (parameters['page'] === undefined) {
                    deferred.reject(new Error('Missing required  parameter: page'));
                    return deferred.promise;
                }

                if (parameters['startTime'] !== undefined) {
                    queryParameters['startTime'] = parameters['startTime'];
                }

                if (parameters['endTime'] !== undefined) {
                    queryParameters['endTime'] = parameters['endTime'];
                }

                if (parameters['senderType'] !== undefined) {
                    queryParameters['senderType'] = parameters['senderType'];
                }

                if (parameters['solutionType'] !== undefined) {
                    queryParameters['solutionType'] = parameters['solutionType'];
                }

                if (parameters['message'] !== undefined) {
                    queryParameters['message'] = parameters['message'];
                }

                if (parameters['from'] !== undefined) {
                    queryParameters['from'] = parameters['from'];
                }

                if (parameters.$queryParameters) {
                    Object.keys(parameters.$queryParameters)
                        .forEach(function(parameterName) {
                            var parameter = parameters.$queryParameters[parameterName];
                            queryParameters[parameterName] = parameter;
                        });
                }

                var url = domain + path;
                var cached = parameters.$cache && parameters.$cache.get(url);
                if (cached !== undefined && parameters.$refresh !== true) {
                    deferred.resolve(cached);
                    return deferred.promise;
                }
                var options = {
                    timeout: parameters.$timeout,
                    method: 'GET',
                    url: url,
                    params: queryParameters,
                    data: body,
                    headers: headers
                };
                if (Object.keys(form).length > 0) {
                    options.data = form;
                    options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
                    options.transformRequest = $nsightCommonSwagger.transformRequest;
                }
                $http(options)
                    .success(function(data, status, headers, config) {
                        deferred.resolve(data);
                        if (parameters.$cache !== undefined) {
                            parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
                        }
                    })
                    .error(function(data, status, headers, config) {
                        deferred.reject({
                            status: status,
                            headers: headers,
                            config: config,
                            body: data
                        });
                    });

                return deferred.promise;
            };
            /**
             * @ngdoc method
             * @name $pushCommon#selectAllSolutionsUsingGET
             * @methodOf $pushCommon


             * @param {object} params
                *
                * ## Parameter
                * | Key   | Require | Default | Description               |
                * |:------|:-------:|:-------:|:--------------------------|

             * @returns {Object} Sender목록을 가져옵니다. promise 객체를 리턴한다.
             *
             */

            $nsightCommonSwagger.prototype.selectAllSolutionsUsingGET = function(parameters) {
                if (parameters === undefined) {
                    parameters = {};
                }
                var deferred = $q.defer();

                var domain = this.domain;
                var path = '/log/solutions';

                var body;
                var queryParameters = {};
                var headers = {};
                var form = {};

                if (parameters.$queryParameters) {
                    Object.keys(parameters.$queryParameters)
                        .forEach(function(parameterName) {
                            var parameter = parameters.$queryParameters[parameterName];
                            queryParameters[parameterName] = parameter;
                        });
                }

                var url = domain + path;
                var cached = parameters.$cache && parameters.$cache.get(url);
                if (cached !== undefined && parameters.$refresh !== true) {
                    deferred.resolve(cached);
                    return deferred.promise;
                }
                var options = {
                    timeout: parameters.$timeout,
                    method: 'GET',
                    url: url,
                    params: queryParameters,
                    data: body,
                    headers: headers
                };
                if (Object.keys(form).length > 0) {
                    options.data = form;
                    options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
                    options.transformRequest = $nsightCommonSwagger.transformRequest;
                }
                $http(options)
                    .success(function(data, status, headers, config) {
                        deferred.resolve(data);
                        if (parameters.$cache !== undefined) {
                            parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
                        }
                    })
                    .error(function(data, status, headers, config) {
                        deferred.reject({
                            status: status,
                            headers: headers,
                            config: config,
                            body: data
                        });
                    });

                return deferred.promise;
            };
            /**
             * @ngdoc method
             * @name $pushCommon#pushAllMessageUsingGET
             * @methodOf $pushCommon


             * @param {object} params
                *
                * ## Parameter
                * | Key   | Require | Default | Description               |
                * |:------|:-------:|:-------:|:--------------------------|

                 * | message | X | X | 메세지 |


                 * | empNo | X | X | 대상 사번, 입력안하면 전체에게 보낸다 |


                 * | type | X | X | OS타입, 특정 OS에게만 보내고 싶을때 기입 |


             * @returns {Object} 푸시 메세지를 보냅니다. promise 객체를 리턴한다.
             *
             */

            $nsightCommonSwagger.prototype.pushAllMessageUsingGET = function(parameters) {
                if (parameters === undefined) {
                    parameters = {};
                }
                var deferred = $q.defer();

                var domain = this.domain;
                var path = '/push';

                var body;
                var queryParameters = {};
                var headers = {};
                var form = {};

                if (parameters['message'] !== undefined) {
                    queryParameters['message'] = parameters['message'];
                }

                if (parameters['empNo'] !== undefined) {
                    queryParameters['empNo'] = parameters['empNo'];
                }

                if (parameters['type'] !== undefined) {
                    queryParameters['type'] = parameters['type'];
                }

                if (parameters.$queryParameters) {
                    Object.keys(parameters.$queryParameters)
                        .forEach(function(parameterName) {
                            var parameter = parameters.$queryParameters[parameterName];
                            queryParameters[parameterName] = parameter;
                        });
                }

                var url = domain + path;
                var cached = parameters.$cache && parameters.$cache.get(url);
                if (cached !== undefined && parameters.$refresh !== true) {
                    deferred.resolve(cached);
                    return deferred.promise;
                }
                var options = {
                    timeout: parameters.$timeout,
                    method: 'GET',
                    url: url,
                    params: queryParameters,
                    data: body,
                    headers: headers
                };
                if (Object.keys(form).length > 0) {
                    options.data = form;
                    options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
                    options.transformRequest = $nsightCommonSwagger.transformRequest;
                }
                $http(options)
                    .success(function(data, status, headers, config) {
                        deferred.resolve(data);
                        if (parameters.$cache !== undefined) {
                            parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
                        }
                    })
                    .error(function(data, status, headers, config) {
                        deferred.reject({
                            status: status,
                            headers: headers,
                            config: config,
                            body: data
                        });
                    });

                return deferred.promise;
            };
            /**
             * @ngdoc method
             * @name $pushCommon#selectUsersUsingGET
             * @methodOf $pushCommon


             * @param {object} params
                *
                * ## Parameter
                * | Key   | Require | Default | Description               |
                * |:------|:-------:|:-------:|:--------------------------|

                 * | empNm | X | X | 사용자 이름 |


                 * | empNo | X | X | 사용자 사번 |


                 * | type | X | X | 사용자 OS |


             * @returns {Object} 사용자 정보를 가져온다. promise 객체를 리턴한다.
             *
             */

            $nsightCommonSwagger.prototype.selectUsersUsingGET = function(parameters) {
                if (parameters === undefined) {
                    parameters = {};
                }
                var deferred = $q.defer();

                var domain = this.domain;
                var path = '/users';

                var body;
                var queryParameters = {};
                var headers = {};
                var form = {};

                if (parameters['empNm'] !== undefined) {
                    queryParameters['empNm'] = parameters['empNm'];
                }

                if (parameters['empNo'] !== undefined) {
                    queryParameters['empNo'] = parameters['empNo'];
                }

                if (parameters['type'] !== undefined) {
                    queryParameters['type'] = parameters['type'];
                }

                if (parameters.$queryParameters) {
                    Object.keys(parameters.$queryParameters)
                        .forEach(function(parameterName) {
                            var parameter = parameters.$queryParameters[parameterName];
                            queryParameters[parameterName] = parameter;
                        });
                }

                var url = domain + path;
                var cached = parameters.$cache && parameters.$cache.get(url);
                if (cached !== undefined && parameters.$refresh !== true) {
                    deferred.resolve(cached);
                    return deferred.promise;
                }
                var options = {
                    timeout: parameters.$timeout,
                    method: 'GET',
                    url: url,
                    params: queryParameters,
                    data: body,
                    headers: headers
                };
                if (Object.keys(form).length > 0) {
                    options.data = form;
                    options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
                    options.transformRequest = $nsightCommonSwagger.transformRequest;
                }
                $http(options)
                    .success(function(data, status, headers, config) {
                        deferred.resolve(data);
                        if (parameters.$cache !== undefined) {
                            parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
                        }
                    })
                    .error(function(data, status, headers, config) {
                        deferred.reject({
                            status: status,
                            headers: headers,
                            config: config,
                            body: data
                        });
                    });

                return deferred.promise;
            };
            /**
             * @ngdoc method
             * @name $pushCommon#insertUsersUsingPOST
             * @methodOf $pushCommon


             * @param {object} params
                *
                * ## Parameter
                * | Key   | Require | Default | Description               |
                * |:------|:-------:|:-------:|:--------------------------|

                 * | user | O | X | user |


             * @returns {Object} 사용자 정보를 입력한다. promise 객체를 리턴한다.
             *
             */

            $nsightCommonSwagger.prototype.insertUsersUsingPOST = function(parameters) {
                if (parameters === undefined) {
                    parameters = {};
                }
                var deferred = $q.defer();

                var domain = this.domain;
                var path = '/users';

                var body;
                var queryParameters = {};
                var headers = {};
                var form = {};

                if (parameters['user'] !== undefined) {
                    body = parameters['user'];
                }

                if (parameters['user'] === undefined) {
                    deferred.reject(new Error('Missing required  parameter: user'));
                    return deferred.promise;
                }

                if (parameters.$queryParameters) {
                    Object.keys(parameters.$queryParameters)
                        .forEach(function(parameterName) {
                            var parameter = parameters.$queryParameters[parameterName];
                            queryParameters[parameterName] = parameter;
                        });
                }

                var url = domain + path;
                var options = {
                    timeout: parameters.$timeout,
                    method: 'POST',
                    url: url,
                    params: queryParameters,
                    data: body,
                    headers: headers
                };
                if (Object.keys(form).length > 0) {
                    options.data = form;
                    options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
                    options.transformRequest = $nsightCommonSwagger.transformRequest;
                }
                $http(options)
                    .success(function(data, status, headers, config) {
                        deferred.resolve(data);
                        if (parameters.$cache !== undefined) {
                            parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
                        }
                    })
                    .error(function(data, status, headers, config) {
                        deferred.reject({
                            status: status,
                            headers: headers,
                            config: config,
                            body: data
                        });
                    });

                return deferred.promise;
            };
            /**
             * @ngdoc method
             * @name $pushCommon#deleteUsersUsingDELETE
             * @methodOf $pushCommon


             * @param {object} params
                *
                * ## Parameter
                * | Key   | Require | Default | Description               |
                * |:------|:-------:|:-------:|:--------------------------|

                 * | empNo | X | X | 사용자 사번 |


             * @returns {Object} 사번으로 사용자 정보를 삭제한다. promise 객체를 리턴한다.
             *
             */

            $nsightCommonSwagger.prototype.deleteUsersUsingDELETE = function(parameters) {
                if (parameters === undefined) {
                    parameters = {};
                }
                var deferred = $q.defer();

                var domain = this.domain;
                var path = '/users';

                var body;
                var queryParameters = {};
                var headers = {};
                var form = {};

                if (parameters['empNo'] !== undefined) {
                    queryParameters['empNo'] = parameters['empNo'];
                }

                if (parameters.$queryParameters) {
                    Object.keys(parameters.$queryParameters)
                        .forEach(function(parameterName) {
                            var parameter = parameters.$queryParameters[parameterName];
                            queryParameters[parameterName] = parameter;
                        });
                }

                var url = domain + path;
                var options = {
                    timeout: parameters.$timeout,
                    method: 'DELETE',
                    url: url,
                    params: queryParameters,
                    data: body,
                    headers: headers
                };
                if (Object.keys(form).length > 0) {
                    options.data = form;
                    options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
                    options.transformRequest = $nsightCommonSwagger.transformRequest;
                }
                $http(options)
                    .success(function(data, status, headers, config) {
                        deferred.resolve(data);
                        if (parameters.$cache !== undefined) {
                            parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
                        }
                    })
                    .error(function(data, status, headers, config) {
                        deferred.reject({
                            status: status,
                            headers: headers,
                            config: config,
                            body: data
                        });
                    });

                return deferred.promise;
            };

            return $nsightCommonSwagger;
        })();

        return $nsightCommonSwagger;
    }]);

Copy of Angular JS

By Praveen Poonia

Source: sw y

Copy of Angular JS

  • 1,111

More from Praveen Poonia