Example #1
0
        public void GenerateTxtResultUserTest()
        {
            var userResults = new List <UserResult>
            {
                new UserResult {
                    User = @"First", Result = new Dictionary <DateTime, int> {
                        { new DateTime(2010, 12, 15), 50 }, { new DateTime(2013, 10, 5), 90 }
                    }
                },
                new UserResult {
                    User = @"Second", Result = new Dictionary <DateTime, int> {
                        { new DateTime(2010, 11, 13), 35 }, { new DateTime(2012, 6, 25), 15 }
                    }
                }
            };

            var path            = _resultFileGenerator.GenerateAsText(userResults);
            var content         = File.ReadAllLines(path);
            var expectedContent = File.ReadAllLines(Path.Combine(WorkFolder, @"UsersResult.txt"));

            Assert.That(content, Is.EqualTo(expectedContent));
        }
Example #2
0
        /// <inheritdoc />
        public async Task <string> GetStatisticForUsers(ICollection <string> users, DateTime startDate, int identifier)
        {
            if (!await IsUserAdmin(identifier))
            {
                return(string.Empty);
            }

            var results = new List <UserResult>();
            var query   = $"SELECT username, result, finishtime FROM {UserResultsTable} WHERE (finishtime > convert(datetime,'{startDate:dd-MM-yy}', 5) AND username IS NOT NULL)";

            if (users != null && users.Any())
            {
                query += @" AND (" + string.Join(@" OR ", users.Select(user => $"username = '******'")) + @")";
            }


            query += @";";
            try
            {
                await _connection.OpenAsync().ConfigureAwait(false);

                using (var command = new SqlCommand(query, _connection))
                {
                    var reader = await command.ExecuteReaderAsync().ConfigureAwait(false);

                    while (await reader.ReadAsync().ConfigureAwait(false))
                    {
                        var user   = reader.GetString(0);
                        var result = (int)reader.GetDouble(1);
                        var date   = reader.GetDateTime(2);
                        if (results.Any(item => item.User == user))
                        {
                            results[results.FindIndex(item => item.User == user)].Result[date] = result;
                        }
                        else
                        {
                            results.Add(new UserResult {
                                User = user, Result = new Dictionary <DateTime, int> {
                                    { date, result }
                                }
                            });
                        }
                    }
                }
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
                if (Logger.IsErrorEnabled)
                {
                    Logger.Error(@"Не удалось получить результаты пользователей!", exception);
                }

                return(string.Empty);
            }
            finally
            {
                _connection.Close();
            }

            foreach (var result in results)
            {
                var sortedResult  = new SortedDictionary <DateTime, int>(result.Result);
                var keyValuePairs = sortedResult.OrderBy(item => item.Key);
                result.Result = keyValuePairs.ToDictionary(item => item.Key, item => item.Value);
            }

            if (OutputFileType.Equals(StatisticOutputFileType.Image))
            {
                return(_resultFileGenerator.GenerateAsImage(results));
            }

            if (OutputFileType.Equals(StatisticOutputFileType.Text))
            {
                return(_resultFileGenerator.GenerateAsText(results));
            }

            throw new ArgumentOutOfRangeException("", OutputFileType, @"Неизвестный тип выходного файла!");
        }