public async Task <IEnumerable <Dictionary <string, string> > > GetTaskResult(string groupId, string taskId, string sortAttribute, bool ascending, params string[] selection)
        {
            DynamoDBStructure dynamoDbStructure = TaskConfigurationService.GetDynamoDBStructure(groupId, taskId);

            string table = $"{groupId}{taskId}";

            IEnumerable <Dictionary <string, string> > result;
            List <Dictionary <string, string> >        raw = new List <Dictionary <string, string> >();

            if (selection == null || selection.Length == 0)
            {
                var scanResult = await DynamoDB.ScanAsync(table, new List <string>(dynamoDbStructure.Attributes));

                scanResult.Items.ForEach(r =>
                {
                    var dict = new Dictionary <string, string>();

                    foreach (var kvp in r)
                    {
                        dict.Add(kvp.Key, kvp.Value.S);
                    }

                    raw.Add(dict);
                });
            }
            else
            {
                QueryRequest request = new QueryRequest();
                request.TableName = table;
                request.ExpressionAttributeValues = new Dictionary <string, AttributeValue>();

                for (int i = 0; i < selection.Length; i += 2)
                {
                    var condition = $"{selection[i]}=:a{i+1}";

                    if (i == 0)
                    {
                        request.KeyConditionExpression = condition;
                    }
                    else
                    {
                        request.KeyConditionExpression = request.KeyConditionExpression + $" AND {condition}";
                    }

                    request.ExpressionAttributeValues.Add($":a{i+1}", new AttributeValue(selection[i + 1]));
                }

                var response = await DynamoDB.QueryAsync(request);

                response.Items.ForEach(r =>
                {
                    var dict = new Dictionary <string, string>();

                    foreach (var kvp in r)
                    {
                        dict.Add(kvp.Key, kvp.Value.S);
                    }

                    raw.Add(dict);
                });
            }

            result = raw;

            if (!string.IsNullOrEmpty(sortAttribute))
            {
                result = ascending ?
                         raw.OrderBy(p => Convert.ToDouble(p[sortAttribute], CultureInfo.InvariantCulture)) :
                         raw.OrderByDescending(p => Convert.ToDouble(p[sortAttribute], CultureInfo.InvariantCulture));
            }

            return(result);
        }
        public async Task <Result> StartDataServer()
        {
            if (EC2Client == null || TaskConfigurationService == null)
            {
                return new Result()
                       {
                           ErrorCode = Constants.ErrorCodes.FAILURE
                       }
            }
            ;

            InstanceConfiguration instanceConfiguration = TaskConfigurationService.GetDataPreparationConfiguration();

            var runInstanceResponse = await Instances.LaunchInstance(EC2Client, instanceConfiguration);

            var instanceId = runInstanceResponse.Reservation.Instances[0].InstanceId;

            bool isInstanceRunning = false;
            DescribeInstanceStatusResponse describeInstanceStatusResponse;

            GetInstanceStatusRequestConfiguration instanceStatusReqConfig = new GetInstanceStatusRequestConfiguration()
            {
                InstanceIds = new List <string>()
                {
                    instanceId
                },
                IncludeAllInstances = true
            };

            // timeout?
            while (!isInstanceRunning)
            {
                describeInstanceStatusResponse = await Instances.GetInstanceStatus(EC2Client, instanceStatusReqConfig);

                var instance = describeInstanceStatusResponse.InstanceStatuses.Where(i => i.InstanceId == instanceId)
                               .FirstOrDefault();

                if (instance != null)
                {
                    switch (instance.InstanceState.Code)
                    {
                    case INSTANCE_STATE_CODE_PENDING:
                        continue;

                    case INSTANCE_STATE_CODE_RUNNING:
                        isInstanceRunning = true;
                        break;

                    default:
                        throw new System.Exception("Instance stopped.");
                    }
                }
                else
                {
                    throw new System.Exception("Instance not found.");
                }
            }

            return(new Result {
                ErrorCode = Constants.ErrorCodes.OK
            });
        }