Streamline callEntities adaptor (#226)

* Streamline main callflow rules array rebuild

* Indent control flow correctly

* Streamline call entities adaptor

submodules/strategy/strategy.js

@@ -3734,180 +3734,168 @@ define(function(require) {
 
 		strategyGetCallEntities: function(callback) {
 			var self = this;
-			monster.parallel(
-				{
-					callQueues: function(_callback) {
-						self.strategyListCallflows({
+			monster.parallel({
+				callQueues: function(_callback) {
+					self.strategyListCallflows({
+						filters: {
+							'filter_flow.module': 'qubicle'
+						},
+						success: function(callQueuesData) {
+							_callback(null, callQueuesData);
+						}
+					});
+				},
+				users: function(_callback) {
+					self.callApi({
+						resource: 'user.list',
+						data: {
+							accountId: self.accountId,
 							filters: {
-								'filter_flow.module': 'qubicle'
-							},
-							success: function(callQueuesData) {
-								_callback(null, callQueuesData);
-							}
-						});
-					},
-					users: function(_callback) {
-						self.callApi({
-							resource: 'user.list',
-							data: {
-								accountId: self.accountId,
-								filters: {
-									paginate: 'false'
-								}
-							},
-							success: function(data, status) {
-								_callback(null, data.data);
-							}
-						});
-					},
-					media: function(callback) {
-						self.strategyListMedia(function(media) {
-							callback(null, media);
-						});
-					},
-					userCallflows: function(_callback) {
-						self.callApi({
-							resource: 'callflow.list',
-							data: {
-								accountId: self.accountId,
-								filters: {
-									has_key: 'owner_id',
-									filter_type: 'mainUserCallflow',
-									paginate: 'false'
-								}
-							},
-							success: function(data, status) {
-								var mapCallflowsByOwnerId = _.keyBy(data.data, 'owner_id');
-								_callback(null, mapCallflowsByOwnerId);
-							}
-						});
-					},
-					groups: function(_callback) {
-						self.callApi({
-							resource: 'group.list',
-							data: {
-								accountId: self.accountId,
-								filters: {
-									paginate: 'false'
-								}
-							},
-							success: function(data, status) {
-								_callback(null, data.data);
-							}
-						});
-					},
-					ringGroups: function(_callback) {
-						self.callApi({
-							resource: 'callflow.list',
-							data: {
-								accountId: self.accountId,
-								filters: {
-									'has_key': 'group_id',
-									'filter_type': 'baseGroup'
-								}
-							},
-							success: function(data, status) {
-								_callback(null, data.data);
-							}
-						});
-					},
-					userGroups: function(_callback) {
-						self.callApi({
-							resource: 'callflow.list',
-							data: {
-								accountId: self.accountId,
-								filters: {
-									'has_key': 'group_id',
-									'filter_type': 'userGroup'
-								}
-							},
-							success: function(data, status) {
-								_callback(null, data.data);
+								paginate: 'false'
 							}
-						});
-					},
-					devices: function(_callback) {
-						self.callApi({
-							resource: 'device.list',
-							data: {
-								accountId: self.accountId,
-								filters: {
-									paginate: 'false'
-								}
-							},
-							success: function(data, status) {
-								_callback(null, data.data);
-							}
-						});
-					},
-					advancedCallflows: function(_callback) {
-						self.strategyListCallflows({
+						},
+						success: function(data, status) {
+							_callback(null, data.data);
+						}
+					});
+				},
+				media: function(callback) {
+					self.strategyListMedia(function(media) {
+						callback(null, media);
+					});
+				},
+				userCallflows: function(_callback) {
+					self.callApi({
+						resource: 'callflow.list',
+						data: {
+							accountId: self.accountId,
 							filters: {
-								'filter_ui_is_main_number_cf': true
-							},
-							success: function(advancedCallflowsData) {
-								_callback(null, advancedCallflowsData);
+								has_key: 'owner_id',
+								filter_type: 'mainUserCallflow',
+								paginate: 'false'
 							}
-						});
-					}
-				},
-				function(err, results) {
-					var callEntities = {
-						qubicle: results.callQueues,
-						device: results.devices,
-						user: $.extend(true, [], results.users),
-						play: results.media,
-						userCallflows: [],
-						ring_group: [],
-						userGroups: $.map(results.userGroups, function(val) {
-							var group = _.find(results.groups, function(group) { return val.group_id === group.id; });
-							val.name = group && (group.name || val.name);
-							val.module = 'callflow';
-							return val;
-						}),
-						advancedCallflows: results.advancedCallflows
-					};
-
-					_.forEach(callEntities.qubicle, function(queue) {
-						queue.module = 'callflow';
+						},
+						success: function(data, status) {
+							var mapCallflowsByOwnerId = _.keyBy(data.data, 'owner_id');
+							_callback(null, mapCallflowsByOwnerId);
+						}
 					});
-
-					_.each(callEntities.play, function(media) {
-						media.module = 'play';
+				},
+				groups: function(_callback) {
+					self.callApi({
+						resource: 'group.list',
+						data: {
+							accountId: self.accountId,
+							filters: {
+								paginate: 'false'
+							}
+						},
+						success: function(data, status) {
+							_callback(null, data.data);
+						}
 					});
-
-					_.each(callEntities.device, function(device) {
-						device.module = 'device';
+				},
+				ringGroups: function(_callback) {
+					self.callApi({
+						resource: 'callflow.list',
+						data: {
+							accountId: self.accountId,
+							filters: {
+								'has_key': 'group_id',
+								'filter_type': 'baseGroup'
+							}
+						},
+						success: function(data, status) {
+							_callback(null, data.data);
+						}
 					});
-
-					_.each(results.users, function(user) {
-						if (results.userCallflows.hasOwnProperty(user.id)) {
-							user.id = results.userCallflows[user.id].id;
-							user.module = 'callflow';
-						} else {
-							user.module = 'user';
+				},
+				userGroups: function(_callback) {
+					self.callApi({
+						resource: 'callflow.list',
+						data: {
+							accountId: self.accountId,
+							filters: {
+								'has_key': 'group_id',
+								'filter_type': 'userGroup'
+							}
+						},
+						success: function(data, status) {
+							_callback(null, data.data);
 						}
-						callEntities.userCallflows.push(user);
 					});
-
-					_.each(results.groups, function(group) {
-						var ringGroup = _.find(results.ringGroups, function(ringGroup) { return ringGroup.group_id === group.id; });
-						if (ringGroup) {
-							group.id = ringGroup.id;
-							group.module = 'callflow';
-						} else {
-							group.module = 'ring_group';
+				},
+				devices: function(_callback) {
+					self.callApi({
+						resource: 'device.list',
+						data: {
+							accountId: self.accountId,
+							filters: {
+								paginate: 'false'
+							}
+						},
+						success: function(data, status) {
+							_callback(null, data.data);
 						}
-						callEntities.ring_group.push(group);
 					});
-
-					_.each(results.advancedCallflows, function(callflow) {
-						callflow.module = 'callflow';
+				},
+				advancedCallflows: function(_callback) {
+					self.strategyListCallflows({
+						filters: {
+							'filter_ui_is_main_number_cf': true
+						},
+						success: function(advancedCallflowsData) {
+							_callback(null, advancedCallflowsData);
+						}
 					});
-
-					callback(callEntities);
 				}
-			);
+			}, function(err, results) {
+				callback({
+					advancedCallflows: _.map(results.advancedCallflows, function(callflow) {
+						return _.merge({
+							module: 'callflow'
+						}, callflow);
+					}),
+					device: _.map(results.devices, function(device) {
+						return _.merge({
+							module: 'device'
+						}, device);
+					}),
+					qubicle: _.map(results.callQueues, function(callQueue) {
+						return _.merge({
+							module: 'callflow'
+						}, callQueue);
+					}),
+					play: _.map(results.media, function(media) {
+						return _.merge({
+							module: 'play'
+						}, media);
+					}),
+					ring_group: _.map(results.groups, function(group) {
+						var ringGroup = _.find(results.ringGroups, { group_id: group.id });
+
+						return _.merge({}, group, {
+							id: _.get(ringGroup, 'id', group.id),
+							module: _.isUndefined(ringGroup) ? 'ring_group' : 'callflow'
+						});
+					}),
+					user: results.users,
+					userCallflows: _.map(results.users, function(user) {
+						return _.merge({}, user, {
+							id: _.get(results.userCallflows, [user.id, 'id'], user.id),
+							module: _.has(results.userCallflows, user.id) ? 'callflow' : 'user'
+						});
+					}),
+					userGroups: _.map(results.userGroups, function(userGroup) {
+						var group = _.find(results.groups, { id: userGroup.group_id });
+
+						return _.merge({}, userGroup, {
+							name: _.get(group, 'name', userGroup.name),
+							module: 'callflow'
+						});
+					})
+				});
+			});
 		},
 
 		strategyGetVoicesmailBoxes: function(callback) {
@@ -3981,26 +3969,17 @@ define(function(require) {
 		strategyRebuildMainCallflowRuleArray: function(strategyData) {
 			var self = this,
 				mainCallflow = strategyData.callflows.MainCallflow,
-				rules = strategyData.temporalRules,
-				ruleArray = [];
-
-			_.each(rules.holidays, function(val, key) {
-				if (val.id in mainCallflow.flow.children) {
-					ruleArray.push(val.id);
-				}
-			});
-
-			if (rules.lunchbreak.id in mainCallflow.flow.children) {
-				ruleArray.push(rules.lunchbreak.id);
-			}
-
-			_.each(rules.weekdays, function(val, key) {
-				if (val.id in mainCallflow.flow.children) {
-					ruleArray.push(val.id);
-				}
-			});
-
-			mainCallflow.flow.data.rules = ruleArray;
+				rules = strategyData.temporalRules;
+
+			mainCallflow.flow.data.rules = _
+				.chain([
+					_.map(rules.holidays, 'id'),
+					_.has(rules.lunchbreak, 'id') ? [rules.lunchbreak.id] : [],
+					_.map(rules.weekdays, 'id')
+				])
+				.flatten()
+				.filter(_.partial(_.has, mainCallflow.flow.children))
+				.value();
 		},
 
 		strategyListCallflows: function(args) {