I spent ten days to do an app, named a microverarial loan, thinking of a sack of a sack, but …

About $http

I did not directly expose the interface's url address, $http request, etc. to Controller, but did a Layer encapsulation, I call it as sack (that is, the name of the App):

javascriptapp.factory('sack', [
'$http',
'$q',
'$log',
'$location',
'$ionicPopup',
'$storage',
'API_VERSION', 
'API_PROTOCOL',
'API_HOSTNAME',
'API_URI_MAP',
'util',
 function(
 $http,
 $ q,
 $log,
 $location,
 $ionicPopup,
 $storage,
 API_VERSION,
 API_PROTOCOL,
 API_HOSTNAME,
 API_URI_MAP,
 u til
 ){
 var HTTPUnknownError = {code: -1, message:'An unknown error occurred'};
 var HTTPAuthFaildError = {code: -1, message:'Authorization failed'}; 
 var APIPanicError = {code: -1, message:'An unknown error occurred on the server side'};
 var _host = API_PROTOCOL +'://' + API_HOSTNAME +'/',
 _map = API_URI_MAP,
 _apiVersion = API_VERSION,
 _token = (function(){return $storage.token;}()) ;

 setInterval(function(){
 _token = (function(){return $storage.token;}());
 //$log.info("Got Token: "+ _token);
 }, 1000);

 var appendTransform = function(defaultFunc, transFunc) {
 // We can't guarantee that the default transformation is an array
 defaultFunc = angular.isArray(defaultFunc)? defaultFunc: [ defaultFunc];

 // Append the new transformation to the defaults
 return defaultFunc.concat(transFunc);
 };

 var _prepareRequestData = function (originData) {
 originData.token = _token;
 originData.apiVersion = _apiVersion;
 originData.requestId = util.getRandomUniqueRequestId();
 return originData;
 };

 var _prepareRequestJson = function(originData) {
 return angular.toJson({
 apiVersion: _apiVersion,
 token: _token,
 requestId: util.getRandomUniqueRequestId(),
 data: originData
 });
 };

 var _getUriObject = function(uon) {
 // If the incoming parameter has a _host header< br /> if((typeof uon ==='string' && (uon.indexOf(_host) == 0)) || uon ==='') {
 return {
 uri: uon .replace(_host,''),
 methods: ['post']
 };
 }

 if(typeof _map ==='undefined') {
 return {
 uri:'',
 methods: ['post']
 };
 }

 var _uon = uon .split('.'),
 _ns,
 _n;

 if(_uon.length == 1) {
 return {
 uri:'',
 methods: ['post']
 };
 }
 _ns = _uon[0];
 _n = _uon[1];

 _mod = _map[_ns];

 if(typeof _mod ==='undefined') {
 return {
 uri:'',
 methods: ['post']
 };
 }

 _uriObject = _mod[_n];

 if(typeof _uriObject ==='undefined') {
 return {
 uri:'' ,
 methods: ['post']
 };
 }

 return _uriObject;
 };

 var _getUri = function(uon) {
 return _getUriObject(uon).uri;
 };

 var _getUrl = function(uon) {
 return _host + _getUri(uon );
 };

 var _auth = function(uon) {
 var _uo = _getUriObject(uon),
 _authed = false;
 $log .log('Check Auth of : '+ uon);
 $log.log('Is this api need auth:' + angular.toJson(_uo.needAuth));
 $log.log('Is check passed: '+ angular.toJson(!(!_token && _uo.needAuth)));
 $log.log('Token is: '+ _token);
 if(!_token && _uo.needAuth) {

 $ionicPopup.alert({
 title:'Prompt',
 subTitle:'Your current login status has expired, please log in again. '
 }).then(function(){
 $location.path('/sign');
 });

 $location.path(' /sign');
} else {
 _authed = true;
 }
 return _authed;
 };

 var get = function (uon) {
 return $http.get(_getUrl(uon));
 };

 var post = function(uon, data, headers) {
 var _url = _getUrl(uon),
 _data = _prepareRequestData(data);
 $log.info('========> POST START ['+ uon +'] === =====>');
 $log.log('REQUEST URL: '+ _url);
 $log.log('REQUEST DATA:' + angular.toJson(_data)); 

 return $http.post(_url, _data, {
 transformResponse: appendTransform($http.defaults.transformResponse, function(value) {
 $log.log('RECEIVED JSON: '+ angular.toJson(value));
 if(typeof value.ex !='undefined') {
 return {
 error: APIPanicError
 };
 }
 return value;
 })
 });
 };

 var promise = function(uon, data , headers) {
 var defer = $q.defer();

 if(!_auth(uon)) {
 defer.reject(HTTPAuthFaildError);
 return defer.promise;
 }

 post(uon, data, headers).success(function(res){
 if(res.error) {
 defer .reject(res.error);
} else {
 defer.resolve(res.data);
 }
 }).error(function(res){
 defer.reject(HTTPUnknownError);
 });
 return defer.promise;
 };

 var postJson = function(uon, data, headers) { 
 var _url = _getUrl(uon),
 _json = _prepareRequestJson(data);
 $log.info('========> POST START ['+ uon +' ] ========>');
 $log.log('REQUEST URL: '+ _url);
 $log.log('REQUEST JSON:' + _json);< br /> return $http.post(_url, _json, {
 transformResponse: appendTransform($http.defaults.transformResponse, function(value) {
 $log.log('RECEIVED JSON: '+ angular.toJson( value));
 if(typeof value.ex !='undefined') {
 return {
 error: APIPanicError
 };
 }
 return value;
 })
 });
 };

 var promiseJson = function(uon, data, headers) {
 var defer = $q .defer();

 if(!_auth(uon)) {
 defer.reject(HTTPAuthFaildError);
 return defer.promise;
 }

 postJson(uon, data, headers).success(function(res){
 if(res.error) {
 defer.reject(res.error);
} else {
 defer.resolve(res.data);
 }
 }).error(function(res){
 defer.reject(HTTPUnknownError);
} );
 return defer.pr omise;
 };

 return {
 get: get,
 post: post,
 promise: promise,

 postJson: postJson,
 promiseJson: promiseJson,
 _auth: _auth,
 HTTPAuthFaildError: HTTPAuthFaildError
 };
 }
]);

< p>In this way, the most important method is to use one method: sack.promiseJson, this method is to send a request to the server with json data, and then return a promise Of.

The data structure of the above API_URI_MAP is similar to the following:

javascriptapp.constant('API_URI_MAP', {
 user: {< br /> sign: {
 needAuth: false,
 uri:'sack/user/sign.json',
 methods: [
'post'
 ], 
 params: {
 mobile:'string', // mobile phone number
 captcha:'string' // verification code
 }
 },
 unsign : {
 needAuth: true,
 uri:'sack/user/unsign.json',
 methods: [
'post'
 ],
 params: {
 token:'string'
 }
 },
 //...
 }
 //...
 });

Then, to be more specific, the sack.promiseJson method is not used directly in the Controller, but the packaged service is used For example, the following service:

javascriptapp.factory('UserService', function($rootScope, $q, $storage, API_CACHE_TIME, sack) {
 var sign = function(data) { 
 return sack.promiseJson('user.sign', data);
 };

 return {
 sign: sign< br /> }
});

The advantage of this is that I can directly initiate a request like the following:

UserService.sign({mobile:'xxxxxxxxxxx' ,captcha:'000000')).then(function(res){
 // authorization succeeded
}, function(err){
 // authorization failed
}); 

But

Ok, but again, after the App is finished, our lovely leaders feel that this is okay, and then they will start to play their various NB Fortunately, we did not use working hours from the beginning, which gave us reason to reject the leadership’s guidance. However, the company said, if you don’t accept the guidance, then you won’t let it go. Well, then don’t go. It seems to irritate our leaders, so we just started recruiting for the app without ventilating with us. I immediately wanted to ask:

Our strategy is not to say not to do the app? ? How can I see that the App is easier than it is now and I started to do it again

Then I thought of another possibility

1. We uploaded the App,

   li>

2. Another leader recruited some newcomers and made an app
3. If the app is okay, copy our functions directly and let us go offline

< li>Then the leader can take credit again

4. If the App can’t, then we’re wasting time, taking our offline, and then...

Anyway, It seems that it has nothing to do with me, unless the app is not operating well.