/*	Service(s)
===================================*/

vendor.factory('appCache', ['$cacheFactory', function ($cacheFactory) {
	var cache = $cacheFactory('FinApp', { storageMode: 'sessionStorage' });
	cache.callbackQueue = {};
	cache.persistantCallbackQueue = {};
	cache.processCallbackQueue = function (apiKey, response) {
		if (this.callbackQueue[apiKey]) {
			var callback = null;
			while (this.callbackQueue[apiKey] && (callback = this.callbackQueue[apiKey].shift())) {
				callback(response);
			}
			delete this.callbackQueue[apiKey];
		}
	};
	cache.processPersistantCallbackQueue = function (apiKey, response) {
		if (this.persistantCallbackQueue[apiKey]) {
			var callback = null;
			for (var i in this.persistantCallbackQueue[apiKey]) {
				this.persistantCallbackQueue[apiKey][i](response);
			}
		}
	};
	return cache;
}])
	.factory('appInfo', ['$q', '$rootScope', '$http', '$location', 'appCache', 'Storage', 'Upload', '$timeout', function ($q, $rootScope, $http, $location, appCache, Storage, Upload, $timeout) {
		return {
			siteUrl: $location.$$protocol + '://' + $location.$$host + '/',
			appDocumentUploadUrl: $location.$$protocol + '://' + $location.$$host + '/company/DocumentsUpload_Submit',
			appDocumentDownloadUrl: $location.$$protocol + '://' + $location.$$host + '/company/DownloadMediaRequest',
			appDocumentsZipDownloadUrl: $location.$$protocol + '://' + $location.$$host + '/deals/DownloadDocumentsZip',
			CompanyDocumentsZipDownloadUrl: $location.$$protocol + '://' + $location.$$host + '/company/DownloadDocumentsZip',
			applicationDocumentsZipDownloadUrl: $location.$$protocol + '://' + $location.$$host + '/applications/DownloadDocumentsZip',
			serviceUrl: $location.$$protocol + '://' + $location.$$host + '/api/',
			liveConnection: {
				socketConn: false,
				retryConnectionAttempt: 0,
				countdownTimer: false,
				attemptTimer: false,
				attemptScheduled: false,
				init: function () {
					var appInfo = appCache.appInfo;
					appInfo.liveConnection.retryConnectionAttempt++;
					appInfo.liveConnection.attemptScheduled = false;
					appInfo.getSocketData({
						'getChatRoomUpdates': {
							"ClientTZDIFF": $rootScope.uaInfo.ClientTZDIFF
						}
					}, function () {
						$rootScope.Page.reConnectTimer = false;
					});
				}
			},
			getServerData: function (reqData) {
				var deferred = $q.defer();
				var url = Object.keys(reqData)[0];
				if ($rootScope.EmulatedMode) {
					reqData[url].EmulationData = $rootScope.EmulatedMode;
				}
				$rootScope.Page.trackLoading(url);
				$http.post(this.serviceUrl + url, reqData, {
					headers: {
						'X_HTTP_METHOD_OVERRIDE': 'POST',
						'LOADED-COMPANY-DATE': ($rootScope.CompanyPreferences ? $rootScope.CompanyPreferences.ModifiedDate : false)
					}
				}).success(function (data) {
					if (_.isUndefined(data[url])) {
						deferred.reject({ 'ResponseCode': 500, 'Message': 'Error reading response.' });
					}
					else if (data[url].ResponseCode == 535) {
						var EmuData = Storage.getEmulationData();
						if (EmuData && _.isObject(EmuData.emulate)) {
							location.href = '/backToAdmin';
						} else
							$location.path('/SignOut');
						$rootScope.showFlashMessage('error', data[url].Message);
						deferred.reject(data[url]);
					}
					else if (data[url].ResponseCode == 302) {
						$rootScope.showFlashMessage('error', data[url].Message);
						$location.path('/SignOut');
						setTimeout(function () {
							Storage.clear();
							location.reload();
						}, 100);
					} else
						deferred.resolve(data[url]);
					$rootScope.Page.untrackLoading(url);
				}).error(function (data) {
					// $rootScope.showFlashMessage('error','Internal Error Retry Later');
					console.log(url + ' service failed');
					deferred.reject({ 'ResponseCode': 500, 'Message': 'Internal Error Retry Later' });
					$rootScope.Page.untrackLoading(url);
				});
				return deferred.promise;
			},
			getSocketData: function (reqData, callback, isPersistant) {
				if ($rootScope.SignIn && !this.liveConnection.socketConn) {
					this.liveConnection.socketConn = new WebSocket((location.protocol == 'https:' ? 'wss' : 'ws') + '://' + SUBDOMAIN + '.' + MASTER_DOMAIN + ':' + CHAT_PORT + '/echo/?' + $rootScope.SignIn.LoginSessionKey);
					appCache.appInfo = this;
					$rootScope.socketConn = this.liveConnection.socketConn;
					this.liveConnection.socketConn.onopen = function (e) {
						if (appCache.callbackQueue['socketOpen']) {
							for (var i in appCache.callbackQueue['socketOpen']) {
								appCache.appInfo.liveConnection.socketConn.send(JSON.stringify(appCache.callbackQueue['socketOpen'][i]));
							}
							appCache.callbackQueue['socketOpen'] = [];
						}
					}
					this.liveConnection.socketConn.onmessage = this.processSocketResponse;
					this.liveConnection.socketConn.onerror = this.socketConnectionFix;
					this.liveConnection.socketConn.onclose = this.socketConnectionFix;
				}
				if (reqData) {
					var callbackKey = Object.keys(reqData)[0];
					if (_.isFunction(callback)) {
						var q = !isPersistant ? 'callbackQueue' : 'persistantCallbackQueue';
						if (appCache[q][callbackKey]) {
							appCache[q][callbackKey].push(callback);
						}
						else
							appCache[q][callbackKey] = [callback];
					}
					if (this.liveConnection.socketConn.readyState == 1) {
						this.liveConnection.socketConn.send(JSON.stringify(reqData));
					} else {
						var callbackKey = 'socketOpen';
						if (_.isFunction(callback)) {
							if (appCache.callbackQueue[callbackKey]) {
								appCache.callbackQueue[callbackKey].push(reqData);
							}
							else
								appCache.callbackQueue[callbackKey] = [reqData];
						}
					}
				}
			},
			disconnectSocket: function () {
				if (this.liveConnection.socketConn) {
					this.liveConnection.socketConn.close();
					delete this.liveConnection.socketConn;
					$rootScope.Page.reConnectTimer = false;
				}
			},
			socketConnectionFix: function (e) {
				var appInfo = appCache.appInfo;
				if ($rootScope.SignIn && !appInfo.liveConnection.attemptScheduled) {
					appInfo.liveConnection.attemptScheduled = true;
					appInfo.liveConnection.socketConn = false;
					var retryTime = 15000 * appInfo.liveConnection.retryConnectionAttempt;
					var ticker = retryTime / 1000;
					var countdown = function () {
						ticker--;
						if (ticker > 0) {
							if (ticker > 60) {
								$rootScope.Page.reConnectTimer = (ticker / 60).toFixed(2) + 'm';
							} else {
								$rootScope.Page.reConnectTimer = ticker + 's';
							}
							appInfo.liveConnection.countdownTimer = $timeout(countdown, 1000);
						} else {
							$rootScope.Page.reConnectTimer = false;
						}
					}
					countdown();
					appInfo.liveConnection.attemptTimer = $timeout(appInfo.liveConnection.init, retryTime);
				}
			},
			processSocketResponse: function (response) {
				var appInfo = appCache.appInfo;
				appInfo.liveConnection.retryConnectionAttempt = 0;
				$rootScope.Page.reConnectTimer = false;
				var responseData = JSON.parse(response.data);
				var callbackKey = Object.keys(responseData)[0];
				appCache.processCallbackQueue(callbackKey, responseData);
				appCache.processPersistantCallbackQueue(callbackKey, responseData);
			},
			CallUploadFilesApi: function (reqData, success, error, progress, directS3Upload) {
				//return Upload.upload( { url: this.serviceUrl+ url, data: data, } ).then(success, error, progress);
				var deferred = $q.defer();
				var wrapper = Object.keys(reqData)[0];
				var url = this.serviceUrl + wrapper;
				var appInfo = this;
				if ($rootScope.EmulatedMode) {
					reqData[wrapper].EmulationData = $rootScope.EmulatedMode;
				}

				function directUpload() {
					delete reqData.UploadFile.File;
					uploadObject['fields'] = reqData;
					return Upload.upload(uploadObject).then(function (response) {
						success(response.data.UploadFile);
					}, error, progress);
				}

				function s3Upload() {
					AWS.config.update({
						region: 'us-west-2',
						credentials: new AWS.CognitoIdentityCredentials({
							IdentityPoolId: 'us-west-2:22c7affc-43c6-4798-bbd7-7d8aea451fc8',
						})
					});
					AWS.config.credentials.get(function (err) {
						if (err)
							console.log(err, AWS.config.credentials);
					});
					var bucket = new AWS.S3({ apiVersion: '2006-03-01', params: { Bucket: 'finapp-web' } });
					var params = { Key: uploadObject.file.name + '-^-' + $rootScope.SignIn.LoginSessionKey, ContentType: uploadObject.file.type, Body: uploadObject.file, ServerSideEncryption: 'AES256' };
					var uploadManager = bucket.upload(params);
					uploadManager.on('httpUploadProgress', function (progressObject) {
						deferred.notify({ uploadPercentage: Math.round(progressObject.loaded / progressObject.total * 100) });
					});
					uploadManager.send(function (err, data) {
						if (err) {
							deferred.reject(err);
						}
						else {
							reqData[wrapper].File = {
								'Name': uploadObject.file.name,
								'Type': uploadObject.file.type,
								'Size': uploadObject.file.size
							};
							appInfo.getServerData(reqData).then(function (response) {
								deferred.resolve(response);
							}, function (response) {
								deferred.reject(response);
							});
						}
					});

					return deferred.promise;
				}

				$rootScope.uploading = true;
				var uploadObject = {
					"url": url,
					headers: { 'X_HTTP_METHOD_OVERRIDE': 'POST' },
					file: reqData.UploadFile.File,
					sendFieldsAs: "json"
				};

				if (_.isUndefined(directS3Upload) ? PROCESS_S3_UPLOAD : directS3Upload)
					return s3Upload().then(success, error, progress);
				else
					return directUpload();
			},
			getChatRooms: function (reqData, callback) {
				this.getServerData({
					"activeChatRooms": reqData
				}).then(function (response) {
					callback(response);
				}, function () {
					$rootScope.showFlashMessage('error', 'Unable to fetch communication history. Please retry later.');
				});
			},
			getPaginationData: function (pagingData) {
				var fromNo = 0;
				var endNo = 0;
				fromNo = ((pagingData.currentPage - 1) * pagingData.numPerPage) + 1;
				endNo = (pagingData.currentPage * (pagingData.numPerPage));
				if (endNo > pagingData.totalRecord) {
					endNo = pagingData.totalRecord;
				}
				if (pagingData.totalRecord == 1) {
					recordtect = "Record";
				} else {
					recordtect = "Records";
				}
				if (pagingData.totalRecord == 0) {
					pagingData.showingtext = "";
				} else {
					pagingData.showingtext = "Showing " + fromNo + " to " + endNo + " of " + pagingData.totalRecord + " " + recordtect;
				}
				return pagingData.showingtext;
			},
			getIndustryTypes: function (callback) {
				$rootScope.industryData = appCache.get('Industries');
				if (typeof callback != 'undefined') {
					if (appCache.callbackQueue['getIndustryTypes'])
						appCache.callbackQueue['getIndustryTypes'].push(callback);
					else
						appCache.callbackQueue['getIndustryTypes'] = [callback];
				}
				if (typeof $rootScope.industryData == 'undefined') {
					if ($rootScope.Page.Loading.indexOf('industries-list') == -1) {
						var reqDataIndustry = {
							"GetIndustryTypesList": {
								// "LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
								"CompanyID": $rootScope.CompanyPreferences.CompanyID
							}
						};
						this.getServerData(reqDataIndustry).then(function (response) {
							if (response.ResponseCode == 200) {
								$rootScope.industryData = response.Data.Industries;
								appCache.put('Industries', $rootScope.industryData);
								if (typeof callback != 'undefined')
									appCache.processCallbackQueue('getIndustryTypes', response);
							} else {
								$rootScope.showFlashMessage('error', response.Message);
							}
						});
					}
				} else if (typeof callback != 'undefined')
					appCache.processCallbackQueue('getIndustryTypes');
			},
			getFundingProgram: function (callback, forceReload, parameters) {
				if (!forceReload || angular.equals($rootScope.loadingFundingData, parameters)) {
					$rootScope.appliedProgram = appCache.get('FundingProgram');
					var callbackKey = 'getFundingProgram';
				} else {
					$rootScope.appliedProgram = null;
					var callbackKey = 'getFundingProgram_forced';
				}
				if (typeof callback != 'undefined') {
					if (appCache.callbackQueue[callbackKey]) {
						appCache.callbackQueue[callbackKey].push(callback);
					}
					else
						appCache.callbackQueue[callbackKey] = [callback];
				}
				var appInfo = this;
				if (parameters) {
					var trackKey = 'funding-program-' + parameters.ProgramID + '-' + parameters.CreditScoreID + '-' + parameters.TimeInBusinessID;
					$rootScope.Page.trackLoading(trackKey);
				}
				if (!$rootScope.appliedProgram) {
					if ((!$rootScope.loadingFundingData || (forceReload && !angular.equals($rootScope.loadingFundingData, parameters))) && parameters) {
						$rootScope.loadingFundingData = parameters;
						var reqData = {
							"GetFundingProgram": parameters
						};
						appInfo.getUserCreditScores(function () {
							appInfo.getServerData(reqData).then(function (response) {
								if (response.ResponseCode == 200) {
									if (response.Data.AppliedProgram) {
										$rootScope.appliedProgram = response.Data.AppliedProgram;
										appCache.put('FundingProgram', $rootScope.appliedProgram);
									} else {
										delete $rootScope.loadingFundingData;
										appCache.remove('FundingProgram');
									}
									appCache.processCallbackQueue(callbackKey, response);
								} else {
									if (response.ResponseCode != 638) {
										$rootScope.showFlashMessage('error', response.Message);
									}
									if (response.ResponseCode == 111) {
										setTimeout(function () {
											location.href = 'https://finexchange.com/';
										}, 2000);
									} else {
										if (response.ResponseCode == 672) {
											Storage.removeItem('uaInfo');
											Storage.removeItem('CompanyPreferences');
											setTimeout(function () { location.reload() }, 2000);
										}
									}
								}
								$rootScope.Page.untrackLoading(trackKey);
							});
						});
					} else {
						appCache.processCallbackQueue(callbackKey);
						$rootScope.Page.untrackLoading(trackKey);
					}
				} else {
					appCache.processCallbackQueue(callbackKey);
					$rootScope.Page.untrackLoading(trackKey);
				}
			},
			getLegalStructureName: function (callback) {
				$rootScope.legalStructureData = appCache.get('LegalStructureName');
				if (typeof $rootScope.legalStructureData == 'undefined') {
					var reqDataLegalStructure = {
						"GetLegalStructureName": {
							// "LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqDataLegalStructure).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.legalStructureData = response.Data.GetLegalStructureName;
							appCache.put('LegalStructureName', $rootScope.legalStructureData);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getFinancePurposeList: function (callback) {
				$rootScope.FinancePurposeData = appCache.get('FinancePurposeList');
				if (typeof $rootScope.FinancePurposeData == 'undefined') {
					var reqDataFinancePurpose = {
						"GetFinancePurposeList": {
							// "LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqDataFinancePurpose).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.FinancePurposeData = response.Data.GetFinancePurposeList;
							appCache.put('FinancePurposeList', $rootScope.FinancePurposeData);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined') {
					callback();
				}
			},
			getBusinessPurposeList: function (callback) {
				$rootScope.BusinessPurposeData = appCache.get('BusinessPurposeList');
				if (typeof $rootScope.BusinessPurposeData == 'undefined') {
					var reqDataBusinessPurpose = {
						"GetBusinessApplicationPurpose": {
							"LoginSessionKey": null
						}
					};
					this.getServerData(reqDataBusinessPurpose).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.BusinessPurposeData = response.Data;
							appCache.put('BusinessPurposeList', $rootScope.BusinessPurposeData);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined') {
					callback();
				}
			},

			getGetAnnualRevenueList: function (callback) {
				$rootScope.GetAnnualRevenueData = appCache.get('GetAnnualRevenueList');
				if (typeof $rootScope.GetAnnualRevenueData == 'undefined') {
					var reqDataGetAnnualRevenue = {
						"GetAnnualRevenue": {
							"LoginSessionKey": null
						}
					};
					this.getServerData(reqDataGetAnnualRevenue).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.GetAnnualRevenueData = response.Data;
							appCache.put('GetAnnualRevenueList', $rootScope.GetAnnualRevenueData);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined') {
					callback();
				}
			},

			getStates: function (callback) {
				$rootScope.stateData = appCache.get('States');
				if (!_.isUndefined(callback)) {
					if (appCache.callbackQueue['getStates'])
						appCache.callbackQueue['getStates'].push(callback);
					else
						appCache.callbackQueue['getStates'] = [callback];
				}
				if (_.isUndefined($rootScope.stateData)) {
					if (!$rootScope.LoadingStateData) {
						$rootScope.LoadingStateData = TRUE;
						var reqDataState = {
							"GetStatesList": {
								"CountryID": 1
							}
						};
						this.getServerData(reqDataState).then(function (response) {
							if (response.ResponseCode == 200) {
								$rootScope.stateData = response.Data;
								appCache.put('States', response.Data);
								if (!_.isUndefined(callback))
									appCache.processCallbackQueue('getStates');
							} else {
								$rootScope.showFlashMessage('error', response.Message);
							}
							delete $rootScope.LoadingStateData;
						});
					}
				} else if (!_.isUndefined(callback))
					appCache.processCallbackQueue('getStates');
			},
			getequipmenttype: function (callback) {
				$rootScope.equipmenttypes = appCache.get('equipmentTypeList');
				if (_.isUndefined($rootScope.equipmenttypes)) {
					var reqDataUserCreditScores = {
						"GetEquipmentTypes": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqDataUserCreditScores).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.equipmenttypes = response.Data;
							appCache.put('equipmentTypeList', response.Data);
							if (typeof callback != 'undefined')
								callback(response);
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getsyndicateusers: function (callback) {
				$rootScope.syndicateUsers = appCache.get('syndicateUserList');
				if (_.isUndefined($rootScope.syndicateUsers)) {
					var reqDataUserCreditScores = {
						"GetSyndicateUsers": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqDataUserCreditScores).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.syndicateUsers = response.Data;
							appCache.put('syndicateUserList', response.Data);
							if (typeof callback != 'undefined')
								callback(response);
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getUserTypes: function (callback) {
				$rootScope.userTypes = appCache.get('UserTypes');
				if (typeof $rootScope.userTypes == 'undefined') {
					var reqData = {
						"GetUserTypesList": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.userTypes = response.Data.UserTypes;
							appCache.put('UserTypes', $rootScope.userTypes);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined') {
					callback();
				}
			},
			getSalesPersons: function (callback, refresh, CompanyAlias) {
				if (!CompanyAlias) {
					if (!refresh)
						$rootScope.salesPersons = appCache.get('SalesPersons');
					else
						delete $rootScope.salesPersons;
				}
				if (!_.isUndefined(callback)) {
					if (appCache.callbackQueue['SalesPersons' + CompanyAlias])
						appCache.callbackQueue['SalesPersons' + CompanyAlias].push(callback);
					else
						appCache.callbackQueue['SalesPersons' + CompanyAlias] = [callback];
				}
				if (_.isUndefined($rootScope.salesPersons) || (!_.isUndefined(CompanyAlias) && $rootScope.Page.Loading.indexOf('sales-persons' + CompanyAlias) == -1)) {
					$rootScope.Page.trackLoading('sales-persons' + CompanyAlias);
					var reqData = {
						"GetSalesPersonName": {}
					};
					if (!_.isUndefined(CompanyAlias))
						reqData.GetSalesPersonName.Alias = CompanyAlias
					else
						reqData.GetSalesPersonName.Alias = $rootScope.CompanyPreferences.Alias
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							if (!CompanyAlias) {
								$rootScope.salesPersons = response.Data.salesPersons;
								appCache.put('SalesPersons', $rootScope.salesPersons);
							}
							appCache.processCallbackQueue('SalesPersons' + CompanyAlias, response);
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
						$rootScope.Page.untrackLoading('sales-persons' + CompanyAlias);
					});
				} else if (_.isFunction(callback) && _.isUndefined(CompanyAlias)) {
					appCache.processCallbackQueue('SalesPersons' + CompanyAlias);
				}
			},
			getMatchingContacts: _.debounce(function (EmailInitial, PageNo, callback) {
				var reqData = {
					"suggestEmail": {
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
						"Email": EmailInitial,
						"PageNo": PageNo
					}
				};
				this.getServerData(reqData).then(function (response) {
					callback(response);
				});
			}, 1000),
			saveContact: function (contactData, callback) {
				var reqData = {
					"addEditcontact": {
						"SalesLeadID": (contactData.SalesLeadID) ? contactData.SalesLeadID : "",
						"DeviceType": "Web",
						"ContactDetails": {
							"FirstName": contactData.FirstName,
							"LastName": contactData.LastName,
							"PrimaryContactNo": contactData.PrimaryContactNo,
							"SecondaryContactNo": contactData.SecondaryContactNo,
							"FaxNo": contactData.FaxNo,
							"PrimaryContactEmail": contactData.PrimaryContactEmail,
							"SecondaryContactEmail": contactData.SecondaryContactEmail
						},
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
					}
				};
				if (contactData.ProposalGUID)
					reqData.addEditcontact.ProposalGUID = contactData.ProposalGUID;
				this.getServerData(reqData).then(function (response) {
					callback(response);
				});
			},
			addUsers: function (Company, callback) {
				var reqData = {
					"SignUpCompanyUser": {
						"DeviceType": "Web",
						"SocialType": "Web",
						"DeviceID": "Web",
						"SourceID": 1,
						"CompanyUser": Company.companyUsers,
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
						"CompanyID": $rootScope.CompanyPreferences.CompanyID
					}
				};
				this.getServerData(reqData).then(function (response) {
					callback(response);
				});
			},
			getStatusList: function (callback, forDeal) {
				$rootScope.statusList = appCache.get('StatusList');
				if (typeof $rootScope.statusList == 'undefined') {
					var reqData = {
						"GetStatusList": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					if (forDeal)
						reqData.GetStatusList.forDeal = forDeal;
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.statusList = response.Data.GetStatusList;
							appCache.put('StatusList', $rootScope.statusList);
							if (_.isFunction(callback))
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (_.isFunction(callback))
					callback();
			},
			getProgramStatusList: function (callback) {
				$rootScope.ProgramStatusList = appCache.get('ProgramStatusList');
				if (typeof $rootScope.ProgramStatusList == 'undefined') {
					var reqData = {
						"GetProgramStatusList": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.ProgramStatusList = response.Data.GetProgramStatusList;
							appCache.put('ProgramStatusList', $rootScope.ProgramStatusList);
							if (_.isFunction(callback))
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (_.isFunction(callback))
					callback();
			},
			getProgramTypeList: function (callback, VFGDataFlag) {
				$rootScope.ProgramTypeList = appCache.get('ProgramTypeList');
				if (typeof $rootScope.ProgramTypeList == 'undefined') {
					var reqData = {
						"GetProgramTypeList": {
							// "LoginSessionKey":  $rootScope.SignIn.LoginSessionKey
						}
					};
					if (VFGDataFlag) {
						reqData.GetProgramTypeList.VFGDataFlag = VFGDataFlag;
					}
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.ProgramTypeList = response.Data.ProgramTypeList;
							appCache.put('ProgramTypeList', $rootScope.ProgramTypeList);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getDealPropertiesForMappings: function (callback) {
				$rootScope.dealPropertiesForMappings = appCache.get('DealPropertiesForMappings');
				if (_.isUndefined($rootScope.dealPropertiesForMappings)) {
					var reqData = {
						"DealPropertiesForMappings": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.dealPropertiesForMappings = response.Data;
							appCache.put('DealPropertiesForMappings', $rootScope.dealPropertiesForMappings);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getMarkerFlags: function (callback) {
				$rootScope.markerFlags = appCache.get('MarkerFlags');
				if (typeof $rootScope.markerFlags == 'undefined') {
					var reqDataMarker = {
						"GetMarkerFlags": {
							"LoginSessionKey": null
						}
					};
					this.getServerData(reqDataMarker).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.markerFlags = response.Data;
							appCache.put('MarkerFlags', response.Data);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			cancelSharedApplication: function (Application, callback, ProgramID) {
				var appInfo = this;
				$rootScope.ngConfirm('Are you sure you want to revoke application ?', function () {
					var reqData = {
						"CancelApplication": {
							"ApplicationNumber": Application.ApplicationNumber,
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
							"ProgramID": _.isUndefined(ProgramID) ? null : ProgramID
						}
					};
					appInfo.getServerData(reqData).then(function (response) {
						if (typeof callback != 'undefined')
							callback(response);
					});
				}, function () {
					return {
						ResponseCode: 2,
						Message: 'Request canceled by user'
					};
				});
			},
			getCalcData: function (LoanData) {

				var calculateRate = function (periods, payment, present, future, type, guess) {
					guess = (guess === undefined) ? 0.01 : guess;
					future = (future === undefined) ? 0 : future;
					type = (type === undefined) ? 0 : type;

					// Set maximum epsilon for end of iteration
					var epsMax = 1e-10;

					// Set maximum number of iterations
					var iterMax = 10;

					// Implement Newton's method
					var y, y0, y1, x0, x1 = 0,
						f = 0,
						i = 0;
					var rate = guess;
					if (Math.abs(rate) < epsMax) {
						y = present * (1 + periods * rate) + payment * (1 + rate * type) * periods + future;
					} else {
						f = Math.exp(periods * Math.log(1 + rate));
						y = present * f + payment * (1 / rate + type) * (f - 1) + future;
					}
					y0 = present + payment * periods + future;
					y1 = present * f + payment * (1 / rate + type) * (f - 1) + future;
					i = x0 = 0;
					x1 = rate;
					while ((Math.abs(y0 - y1) > epsMax) && (i < iterMax)) {
						rate = (y1 * x0 - y0 * x1) / (y1 - y0);
						x0 = x1;
						x1 = rate;
						if (Math.abs(rate) < epsMax) {
							y = present * (1 + periods * rate) + payment * (1 + rate * type) * periods + future;
						} else {
							f = Math.exp(periods * Math.log(1 + rate));
							y = present * f + payment * (1 / rate + type) * (f - 1) + future;
						}
						y0 = y1;
						y1 = y;
						++i;
					}
					return rate;
				};
				var pmt = function ($rate, $nper, $pv, $fv, $type) {
					$rate = _.isUndefined($rate) ? 0 : $rate; $nper = _.isUndefined($nper) ? 0 : $nper; $pv = _.isUndefined($pv) ? 0 : $pv; $fv = _.isUndefined($fv) ? 0 : $fv; $type = _.isUndefined($type) ? 0 : $type;
					if ($rate > 0) {
						return (-$fv - $pv * Math.pow(1 + $rate, $nper)) / (1 + $rate * $type) / ((Math.pow(1 + $rate, $nper) - 1) / $rate);
					} else {
						return (-$pv - $fv) / $nper;
					}
				}
				var calculateEMI = function (rate, usingRateFactor) {
					var Rate = parseFloat(rate) / 100;
					if (usingRateFactor) {
						var Interest = LoanData.FinanceAmount * (Rate * (1 + (LoanData.CommissionPoints / 100)));
						var AmountPayable = parseFloat(Interest).toFixed(2);
					} else {
						var commissionAmount = LoanData.FinanceAmount * LoanData.CommissionPoints / 100;
						if (LoanData.TimeFormat === 'D') {
							var TimeFormat = 365;
						} else if (LoanData.TimeFormat === 'W') {
							var TimeFormat = 52;
						} else if (LoanData.TimeFormat === 'M') {
							var TimeFormat = 12;
						} else if (LoanData.TimeFormat === 'Y') {
							var TimeFormat = 1;
						} else {
							var TimeFormat = 12;
						}
						var Interest = -pmt(Rate / TimeFormat, LoanData.FinanceTenure, LoanData.FinanceAmount + commissionAmount);
						var AmountPayable = parseFloat(Interest).toFixed(2);
					}
					LoanData.appliedRate = (calculateRate(LoanData.FinanceTenure, -AmountPayable, LoanData.FinanceAmount) * 1200).toFixed(2);
					if (isNaN(AmountPayable)) {
						if (LoanData.ShowConfigurationError)
							$rootScope.showFlashMessage('error', $rootScope.CompanyPreferences.CompanyName + ' does not provide leasing for selected configuration.Please select different configuration.');
						return false;
						// console.log('Error',Rate,NewRate,Interest,AmountPayable);
					} else {
						LoanData.AmountPayable = AmountPayable;
						LoanData.InterestRate = Rate;
						return LoanData;
					}
				}
				var appliedProgram = $rootScope.appliedProgram;
				if (!appliedProgram) {
					throw 'Unable to find matching program';
					// console.log(LoanData.FinanceTimeInBusiness,LoanData.FinanceCredit);
				}
				var minAmount = appliedProgram.MinAmount;
				var maxAmount = appliedProgram.MaxAmount;
				LoanData.FinanceAmount = parseFloat(LoanData.FinanceAmount);
				if (!LoanData.CommissionPoints && LoanData.CommissionPoints != 0) {
					if (appliedProgram.CommissionCap)
						LoanData.CommissionPoints = appliedProgram.CommissionCap;
					else
						LoanData.CommissionPoints = $rootScope.CompanyPreferences.DefaultCommissionCap;
				}
				if (LoanData.FinanceAmount > maxAmount || LoanData.FinanceAmount < minAmount) {
					if(LoanData.hasOwnProperty('approveFlag') == -1 && LoanData.approveFlag != 'approveFlag'){
						$rootScope.showFlashMessage('info', "Based on borrower profile (credit score), borrower is eligible only for loan  from $ " +
							minAmount.formatMoney() + ' upto $ ' + maxAmount.formatMoney());
						return false;
					}else{
						return calculateEMI(LoanData.UseCustomRate);
					}
					// $rootScope.CompanyPreferences.CompanyName + " provides loan from $ " + minAmount.formatMoney() + ' upto $ ' + maxAmount.formatMoney()
				} else if (LoanData.UseCustomRate) {
					return calculateEMI(LoanData.UseCustomRate);
				} else if (appliedProgram) {
					var matchingTerm = _.findWhere(appliedProgram.Terms, { Term: parseInt(LoanData.FinanceTenure) });
					if (!matchingTerm) {
						matchingTerm = _.last(appliedProgram.Terms);
						if (LoanData.FinanceTenure)
							$rootScope.showFlashMessage('info', 'Based on borrower profile (credit score), the Maximum allowed term period is ' + matchingTerm.Term + '.');
						return false;
					}
					return calculateEMI(matchingTerm.Rate);
				}
				return false;
			},
			getRateFactor: function (RateOfFactor, Approvedpayment) {
				var payment = parseFloat(Approvedpayment) * parseFloat(RateOfFactor);
				return payment;
			},
			getSignUpStaticData: function (callback, programID) {
				var callbackKey = 'getSignUpStaticData';
				if (typeof callback != 'undefined') {
					if (appCache.callbackQueue[callbackKey])
						appCache.callbackQueue[callbackKey].push(callback);
					else
						appCache.callbackQueue[callbackKey] = [callback];
				}
				$rootScope.TimeInBusiness = appCache.get('TimeInBusiness' + programID);
				if (_.isUndefined($rootScope.TimeInBusiness)) {
					$rootScope.MasterMonths = [
						{ key: '01', MasterMonthValue: 'Jan' },
						{ key: '02', MasterMonthValue: 'Feb' },
						{ key: '03', MasterMonthValue: 'Mar' },
						{ key: '04', MasterMonthValue: 'Apr' },
						{ key: '05', MasterMonthValue: 'May' },
						{ key: '06', MasterMonthValue: 'Jun' },
						{ key: '07', MasterMonthValue: 'July' },
						{ key: '08', MasterMonthValue: 'Aug' },
						{ key: '09', MasterMonthValue: 'Sep' },
						{ key: '10', MasterMonthValue: 'Oct' },
						{ key: '11', MasterMonthValue: 'Nov' },
						{ key: '12', MasterMonthValue: 'Dec' }
					];
					$rootScope.PurposeOfPurchase = [
						{ key: '2', PurposeOfPurchaseValue: 'Add New' },
						{ key: '1', PurposeOfPurchaseValue: 'Replace Existing' },
						{ key: '3', PurposeOfPurchaseValue: 'Add Refurbished' }
					];
					$rootScope.Years = [];
					for (i = $rootScope.currentYear; i >= 1900; i--) {
						$rootScope.Years.push({ Year: i });
					}
					var appInfo = this;
					if (!programID && $rootScope.CompanyPreferences.Category == 'Bank') {
						appInfo.getUserCreditScores();
						programID = $rootScope.CompanyPreferences.DefaultProgramID;
						// console.log(programID);
					}
					appInfo.getTimeInBusiness(function (response) {
						// appInfo.getUserCreditScores(function(response){
						appCache.processCallbackQueue(callbackKey, response);
						// });
					}, { ProgramID: programID });
				}
				else {
					appCache.processCallbackQueue(callbackKey);
				}
			},
			getFormatStaticData: function (FormatId, callback) {
				if (FormatId === 'Y') {
					$rootScope.FormatData = [
						{
							'Term': '1',
							'Rate': '23'
						},
						{
							'Term': '2',
							'Rate': '23'
						},
						{
							'Term': '3',
							'Rate': '23'
						},
						{
							'Term': '4',
							'Rate': '23'
						},
						{
							'Term': '5',
							'Rate': '23'
						},
					];
				} else if (FormatId === 'W') {
					$rootScope.FormatData = [
						{
							'Term': '1',
							'Rate': '23'
						},
						{
							'Term': '2',
							'Rate': '23'
						},
						{
							'Term': '4',
							'Rate': '23'
						},
						{
							'Term': '6',
							'Rate': '23'
						},
						{
							'Term': '8',
							'Rate': '23'
						},
						{
							'Term': '12',
							'Rate': '23'
						},
						{
							'Term': '16',
							'Rate': '23'
						},
					];
				} else if (FormatId === 'D') {
					$rootScope.FormatData = [
						{
							'Term': '15',
							'Rate': '23'
						},
						{
							'Term': '30',
							'Rate': '23'
						},
						{
							'Term': '45',
							'Rate': '23'
						},
						{
							'Term': '60',
							'Rate': '23'
						},
						{
							'Term': '90',
							'Rate': '23'
						},
						{
							'Term': '180',
							'Rate': '23'
						},
						{
							'Term': '365',
							'Rate': '23'
						},
					];
				}
				return callback();
			},
			getTimeInBusiness: function (callback, parameters, unsetDefault) {
				if (_.isFunction(callback)) {
					if (appCache.callbackQueue['getTimeInBusiness'])
						appCache.callbackQueue['getTimeInBusiness'].push(callback);
					else
						appCache.callbackQueue['getTimeInBusiness'] = [callback];
				}
				var cachedData = appCache.get('TimeInBusiness' + parameters.ProgramID);
				if (!unsetDefault)
					$rootScope.TimeInBusiness = cachedData;
				else
					cachedData = undefined;
				if (_.isUndefined(cachedData) && $rootScope.Page.Loading.indexOf('getTimeInBusiness') == -1) {
					var reqDataTimeInBusiness = {
						"GetTimeInBusiness": {
							"ProgramID": _.isUndefined(parameters.ProgramID) ? null : parameters.ProgramID
						}
					};
					if (!_.isUndefined(parameters.ProposalID)) {
						reqDataTimeInBusiness.GetTimeInBusiness.ProposalID = parameters.ProposalID
					}
					this.getServerData(reqDataTimeInBusiness).then(function (response) {
						if (response.ResponseCode == 200 && response.Data) {
							$rootScope.TimeInBusiness = response.Data.Timeinbusiness;
							appCache.put('TimeInBusiness' + parameters.ProgramID, response.Data.Timeinbusiness);
							if (typeof callback != 'undefined')
								appCache.processCallbackQueue('getTimeInBusiness', response);
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (!_.isUndefined(callback))
					appCache.processCallbackQueue('getTimeInBusiness', { Data: { Timeinbusiness: cachedData } });
			},
			getUserCreditScores: function (callback) {
				$rootScope.CreditScores = appCache.get('UserCreditScores');
				if (typeof $rootScope.CreditScores == 'undefined') {
					var reqDataUserCreditScores = {
						"GetUserCreditScores": {
							"LoginSessionKey": null
						}
					};
					this.getServerData(reqDataUserCreditScores).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.CreditScores = response.Data;
							appCache.put('UserCreditScores', response.Data);
							if (typeof callback != 'undefined')
								callback(response);
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getAnnualVolumeSyndicates: function (callback) {
				$rootScope.VolumeSyndicates = appCache.get('AnnualVolumeSyndicates');
				if (typeof $rootScope.VolumeSyndicates == 'undefined') {
					var reqDataUserCreditScores = {
						"GetAnnualVolumeSyndicates": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqDataUserCreditScores).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.VolumeSyndicates = response.Data;
							appCache.put('AnnualVolumeSyndicates', response.Data);
							if (typeof callback != 'undefined')
								callback(response);
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getAssociationList: function (callback, filters) {
				if (!filters)
					$rootScope.AssociationData = appCache.get('AssociationList');
				else
					delete $rootScope.AssociationData;
				if (_.isUndefined($rootScope.AssociationData)) {
					var reqDataAssociations = {
						"GetAssociationList": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
							"Filters": filters
						}
					};
					this.getServerData(reqDataAssociations).then(function (response) {
						if (response.ResponseCode == 200) {
							if (response.Data) {
								$rootScope.AssociationData = response.Data.Associations;
								appCache.put('AssociationList', $rootScope.AssociationData);
								if (typeof callback != 'undefined')
									callback();
							}
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			setLatLong: function (objectReference, callback) {
				if (navigator.geolocation) {
					navigator.geolocation.getCurrentPosition(function (position) {
						objectReference.Latitude = position.coords.latitude;
						objectReference.Longitude = position.coords.longitude;
						if (typeof callback != 'undefined')
							callback();
					}, function () {
						if (typeof callback != 'undefined')
							callback();
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			uploadFile: function (reqData) {
				var deferred = $q.defer();
				var wrapper = Object.keys(reqData)[0];
				var url = this.serviceUrl + wrapper;
				if ($rootScope.EmulatedMode) {
					reqData[wrapper].EmulationData = $rootScope.EmulatedMode;
					// $rootScope.showFlashMessage('error','You are not athorized for this action.');
					// return false;
				}
				var initUpload = function () {
					$rootScope.uploading = true;
					var uploadObject = {
						"url": url,
						headers: { 'X_HTTP_METHOD_OVERRIDE': 'POST' },
						file: reqData.UploadFile.File,
						sendFieldsAs: "json"
					};
					delete reqData.UploadFile.File;
					uploadObject['fields'] = reqData;
					Upload.upload(uploadObject).success(function (data) {
						if (data[wrapper].ResponseCode == 535) {
							$location.path('/SignOut');
							$rootScope.showFlashMessage('error', data[wrapper].Message);
						} else
							deferred.resolve(data[wrapper]);
						delete $rootScope.uploading;
					}).error(function (data) {
						// $rootScope.showFlashMessage('error','Internal Error Retry Later');
						console.log(wrapper + ' service failed');
						deferred.reject({ 'ResponseCode': 500, 'Message': 'Internal Error Retry Later' });
						delete $rootScope.uploading;
					}).progress(function (evt) {
						var progressPercentage = parseInt(100.0 * evt.loaded / evt.total);
						deferred.notify(progressPercentage + '%');
					});
				};
				if ($rootScope.uploading) {
					if (appCache.callbackQueue['uploadFile'])
						appCache.callbackQueue['uploadFile'].push(initUpload);
					else
						appCache.callbackQueue['uploadFile'] = [initUpload];
					deferred.notify('Another upload in progress. Waiting in queue.');
				} else {
					initUpload();
					appCache.processCallbackQueue('uploadFile');
				}
				return deferred.promise;
			},
			getZip: function (input, callback) {
				input.LoginSessionKey = $rootScope.SignIn.LoginSessionKey;
				input.ClientTZDIFF = $rootScope.uaInfo.ClientTZDIFF;
				var reqData = {
					"GetZip": input
				};
				this.getServerData(reqData).then(function (response) {
					if (response.ResponseCode == 200 && (typeof callback != 'undefined')) {
						callback(response);
					} else {
						$rootScope.showFlashMessage('error', response.Message);
					}
				});
			},
			disableCreditScore: function (appliedProgram) {
				var disableCreditScores = [];
				for (var i in appliedProgram.CreditScores) {
					if (appliedProgram.CreditScores[i].Status == 0) {
						disableCreditScores.push(appliedProgram.CreditScores[i].CreditScoreID);
					}
				}
				return disableCreditScores;
			},
			SetAsDefault: function (Message, parameters) {
				var appInfo = this;
				$rootScope.ngConfirm(Message, function () {
					var reqData = {
						"setDefaultProgram": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
							"parameters": parameters
						}
					};
					appInfo.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.CompanyPreferences.DefaultProgramID = response.Data.DefaultProgramID;
							$rootScope.CompanyPreferences.DefaultLoanTerm = response.Data.DefaultLoanTerm;
							$rootScope.CompanyPreferences.DefaultTimeInBusinessID = response.Data.DefaultTimeInBusinessID;
							$rootScope.CompanyPreferences.ProgramName = response.Data.ProgramName;
							Storage.setItem('CompanyPreferences', $rootScope.CompanyPreferences);
							$rootScope.showFlashMessage('success', response.Message);
							return;
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				});
			},
			GrantRevokeProgram: function (callback, Parameters, DisassociateFlag) {
				var reqData = {
					"setProgramAccess": {
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
						"ProgramAccessID": Parameters.ProgramAccessID,
						"PartnerSideCommissionCap": parseInt(Parameters.PartnerSideCommissionCap),
						"LockCommission": Parameters.LockCommission
					}
				};
				if ($rootScope.CompanyPreferences.Category == "Company") {
					reqData.setProgramAccess.VendorSideCommissionCap = Parameters.VendorSideCommissionCap
				}
				if (DisassociateFlag) {
					reqData.setProgramAccess.DisassociateFlag = DisassociateFlag;
				}
				this.getServerData(reqData).then(function (response) {
					if (response.ResponseCode == 200) {
						$rootScope.showFlashMessage('success', response.Message);
						callback();
					} else {
						$rootScope.showFlashMessage('error', response.Message);
					}
				});
			},
			requestProgramAccess: function (callback, Parameters) {
				var reqData = {
					"requestProgramAccess": Parameters
				};
				this.getServerData(reqData).then(function (response) {
					if (response.ResponseCode == 200) {
						callback(response);
					} else {
						$rootScope.showFlashMessage('error', response.Message);
					}
				});
			},
			getAdditionalFieldInputs: function (callback, Application) {
				var reqData = {
					"GetAdditionalFieldInputs": {
						"ApplicationNumber": Application.ApplicationNumber,
						"FetchPreOfferFields": Application.FetchPreOfferFields,
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
					}
				};
				// if(Application)
				this.getServerData(reqData).then(function (response) {
					if (typeof callback != 'undefined')
						callback(response);
				});
			},
			getCompanyPreferences: function (callback, currentVendor) {
				var reqData = {
					"GetCompanyPreferences": {
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
						"CompanyID": currentVendor.CompanyID
					}
				};
				this.getServerData(reqData).then(function (response) {
					if (response.ResponseCode == 200) {
						$rootScope.CompanyData = response.Data;
					} else {
						$rootScope.showFlashMessage('errormza', response.Message);
					}
					if (typeof callback != 'undefined') {
						callback();
					}
				});
			},
			getModuleList: function (callback) {
				$rootScope.moduleList = appCache.get('ModuleList');
				if (typeof $rootScope.moduleList == 'undefined') {
					var reqData = {
						"GetModuleList": {
							"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};

					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.moduleList = response.Data;
							appCache.put('ModuleList', $rootScope.moduleList);
							if (typeof callback != 'undefined') {
								alert('tere');
								callback();
							}
						} else {
							$rootScope.showFlashMessage('errormza', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getCompanyPermissions: function (callback, parameters) {
				var forRootScope = (parameters && parameters.OtherUser) ? false : true;
				$rootScope.companyPermissions = appCache.get('companyPermissions');
				if (_.isFunction(callback)) {
					if (appCache.callbackQueue['getCompanyPermissions' + (forRootScope ? 1 : '')]) {
						appCache.callbackQueue['getCompanyPermissions' + (forRootScope ? 1 : '')].push(callback);
					}
					else
						appCache.callbackQueue['getCompanyPermissions' + (forRootScope ? 1 : '')] = [callback];
				}
				if (!forRootScope || _.isUndefined($rootScope.companyPermissions)) {
					parameters.LoginSessionKey = $rootScope.SignIn.LoginSessionKey;
					var reqData = {
						"GetCompanyPermissions": parameters
					};
					$rootScope.Page.trackLoading('getCompanyPermissions' + (forRootScope ? 1 : ''));
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							if (response.Data) {
								if (forRootScope) {
									$rootScope.companyPermissions = response.Data.permissions;
									appCache.put('companyPermissions', $rootScope.companyPermissions);
								}
								appCache.processCallbackQueue('getCompanyPermissions' + (forRootScope ? 1 : ''), response);
								$rootScope.Page.untrackLoading('getCompanyPermissions' + (forRootScope ? 1 : ''));
							}
						} else {
							$rootScope.showFlashMessage('errormza', response.Message);
						}
					});
				} else if (_.isFunction(callback)) {
					appCache.processCallbackQueue('getCompanyPermissions' + (forRootScope ? 1 : ''));
				}
			},
			processApplicationLogin: function (response) {
				$rootScope.SignIn = response.Data.SignInData;
				if (typeof (Storage) !== "undefined") {
					Storage.setItem('SignIn', $rootScope.SignIn);
				}
				this.getCompanyPermissions(function () {

				}, {
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
					}, TRUE);
			},
			getCompanyTypes: function (callback) {
				$rootScope.CompanyTypesList = appCache.get('CompanyTypesdata');
				if (typeof $rootScope.CompanyTypesList == 'undefined') {
					var reqDataUserCreditScores = {
						"GetCompanyTypes": {
							//"LoginSessionKey": $rootScope.SignIn.LoginSessionKey
						}
					};
					this.getServerData(reqDataUserCreditScores).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.CompanyTypesList = response.Data;
							appCache.put('CompanyTypesdata', response.Data);
							if (typeof callback != 'undefined')
								callback(response);
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			logUserActivity: function (parameters) {
				parameters.LoginSessionKey = $rootScope.SignIn.LoginSessionKey;
				this.getServerData({ "LogActivity": parameters }).then(function (response) {
					if (response.ResponseCode != 200)
						$rootScope.showFlashMessage('error', response.Message);
				}, function (response) {
					$rootScope.showFlashMessage('error', 'Failed to connect with server.');
				});
			},
			updateDealPoolDraft: function (parameters, callback) {
				this.getServerData({
					'UpdateDealPoolDraft': {
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
						"ClientTZDIFF": $rootScope.uaInfo.ClientTZDIFF,
						"DraftID": parameters.DraftID,
						"Data": parameters.Data
					}
				}).then(function (response) {
					if (response.ResponseCode == 200) {
						callback();
					} else {
						$rootScope.showFlashMessage('error', response.Message);
					}
				}, function () {
					$rootScope.showFlashMessage('error', 'Failed to update deal pool draft.');
				});
			},
			getAdditionalData: function (parameters, callback) {
				this.getServerData({
					'ModuleEntityAdditionalData': {
						"LoginSessionKey": $rootScope.SignIn.LoginSessionKey,
						"ClientTZDIFF": $rootScope.uaInfo.ClientTZDIFF,
						"Filters": parameters
					}
				}).then(function (response) {
					if (response.ResponseCode == 200) {
						if (_.isFunction(callback))
							callback(response);
					} else {
						$rootScope.showFlashMessage('error', response.Message);
					}
				}, function () {
					$rootScope.showFlashMessage('error', 'Failed to get additional data.');
				});
			},
			checkMailAccount: function (callback, Parameters, Flag) {
				var reqData = {
					"CheckMailAccount": {
						"LoginSessionKey": $rootScope.SignIn ? $rootScope.SignIn.LoginSessionKey : $rootScope.SignIn,
					}
				};
				if (Parameters)
					reqData.CheckMailAccount.Parameters = Parameters;
				this.getServerData(reqData).then(function (response) {
					$rootScope.SMTPData = null;
					if (response.Data) {
						$rootScope.Page.untrackLoading('mail-account');
						$rootScope.SMTPData = response.Data;
						$rootScope.SignIn.PromoMails = true;
						Storage.setItem('SignIn', $rootScope.SignIn);
						if (response.Data.length == 1)
							$rootScope.UseSMTP = {
								"CompanyMailID": response.Data[0].CompanyMailID
							};
						callback(response);
					}
					/*else if(Flag)
					{
						$rootScope.showFlashMessage('error',"Please add SMTP Details & set Default SMTP Host.");
						$state.go('list-mail-account');
					}
					if($rootScope.CompanyPreferences.Category=="Bank" && !response.Data)
					{
						$rootScope.showFlashMessage('error',"You cannot send proposal because Vendor's SMTP not available.");
						$state.go('proposal-dashboard');
					}*/
				});
			},
			getMailProviders: function (callback) {
				$rootScope.EmailProviders = appCache.get('EmailProviders');
				if (_.isUndefined($rootScope.EmailProviders)) {
					var reqData = {
						"GetMailProviders": {

						}
					};
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.EmailProviders = response.Data.Mailproviders;
							Storage.setItem('EmailProviders', $rootScope.EmailProviders);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			},
			getPaymentSourceType: function (callback) {
				$rootScope.SourceTypes = appCache.get('SourceTypes');
				if (_.isUndefined($rootScope.SourceTypes)) {
					var reqData = {
						"GetPaymentSourceType": {

						}
					};
					this.getServerData(reqData).then(function (response) {
						if (response.ResponseCode == 200) {
							$rootScope.SourceTypes = response.Data.SourceTypes;
							Storage.setItem('SourceTypes', $rootScope.SourceTypes);
							if (typeof callback != 'undefined')
								callback();
						} else {
							$rootScope.showFlashMessage('error', response.Message);
						}
					});
				} else if (typeof callback != 'undefined')
					callback();
			}
		};
	}])
	.factory('Storage', ['$location', '$rootScope', function ($location, $rootScope) {
		return {
			getEmulationData: function () {
				var data = localStorage.getItem('SuperAdmin');
				if (!data) {
					return false;
				} else {
					data = JSON.parse(atob(data));
					if (data.emulate) {
						$rootScope.EmulatedMode = {
							'UserID': null,
							'UserTypeID': data.emulate.UserTypeID,
							'CompanyID': data.emulate.CompanyID
						};
						return data;
					} else
						return false;
				}
			},
			getStoredData: function () {
				var data = localStorage.getItem($location.$$host);
				return (!data) ? {} : JSON.parse(atob(decodeURIComponent(escape(data))));
			},
			setItem: function (Key, Value) {
				var data = null;
				data = this.getStoredData();
				data[Key] = Value;
				localStorage.setItem($location.$$host, btoa(unescape(encodeURIComponent(JSON.stringify(data)))));
			},
			getItem: function (Key) {
				var data = null;
				data = this.getStoredData();
				return data[Key];
			},
			removeItem: function (Key) {
				var data = null;
				data = this.getStoredData();
				delete data[Key];
				localStorage.setItem($location.$$host, btoa(unescape(encodeURIComponent(JSON.stringify(data)))));
			},
			clear: function () {
				localStorage.clear();
			}
		};
	}])
	.factory("ulGeo", ['$window', '$q', '$rootScope', function ($window, $q, $rootScope) {

		var deferred = $q.defer();

		// start socket
		var load = _.once(function () {

			$window.loadgeocomplete = function () {
				$.getScript($rootScope.baseURL + '/js/jquery.geocomplete.js')
					.done(function () { deferred.resolve(); })
					.fail(function () { deferred.reject('could not load ubilabs geocomplete'); });
				delete $window.loadgeocomplete;
			};

			// we need to wait for google maps to do its thing, it'll call loadgeocomplete when its done
			$.getScript('//maps.googleapis.com/maps/api/js?sensor=false&libraries=drawing,geometry,places&key=AIzaSyB_umdBPGS4AbmmARv_Q2fU2UccMbwk3Wc&callback=loadgeocomplete')
				.fail(function () { deferred.reject('could not load google maps'); });
		});

		return function () {
			load();
			return deferred.promise;
		};
	}])
	.filter('tel', function () {
		return function (tel) {
			if (!tel) { return ''; }

			var value = tel.toString().trim().replace(/^\+/, '');

			if (value.match(/[^0-9]/)) {
				return tel;
			}

			var country, city, number;

			switch (value.length) {
				case 10: // +1PPP####### -> C (PPP) ###-####
					country = 1;
					city = value.slice(0, 3);
					number = value.slice(3);
					break;

				case 11: // +CPPP####### -> CCC (PP) ###-####
					country = value[0];
					city = value.slice(1, 4);
					number = value.slice(4);
					break;

				case 12: // +CCCPP####### -> CCC (PP) ###-####
					country = value.slice(0, 3);
					city = value.slice(3, 5);
					number = value.slice(5);
					break;

				default:
					return tel;
			}
			country = '+' + country;
			// if (country == 1) {
			//     country = "";
			// }

			number = number.slice(0, 3) + '-' + number.slice(3);

			return (country + " (" + city + ") " + number).trim();
		};
	})
	.filter('percentage', ['$filter', function ($filter) {
		return function (input, decimals) {
			return $filter('number')(input) + '%';
		};
	}])
	.filter('numberFixedLen', function () {
		return function (a, b) {
			return (1e4 + a + "").slice(-b)
		}
	})
	.filter('ucfirst', function () {
		return function (input, arg) {
			return input.replace(/(?:^|\s)\S/g, function (a) { return a.toUpperCase(); });
		};
	});