more updates to top stats page

Plugins/Stats/Helpers/StatManager.cs

@@ -53,7 +53,7 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                 var thirtyDaysAgo = DateTime.UtcNow.AddMonths(-1);
                 var iqClientRatings = (from rating in context.Set<EFRating>()
 #if !DEBUG
-                                       where rating.RatingHistory.Client.TotalConnectionTime > 3600
+                                       where rating.ActivityAmount > 3600
 #endif
                                        where rating.RatingHistory.Client.Level != Player.Permission.Banned
                                        where rating.RatingHistory.Client.LastConnection > thirtyDaysAgo
@@ -106,6 +106,7 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                     LastSeen = Utilities.GetTimePassed(clientRatingsDict[s.ClientId].LastConnection, false),
                     Name = clientRatingsDict[s.ClientId].Name,
                     Performance = Math.Round(clientRatingsDict[s.ClientId].Performance, 2),
+                    RatingChange = clientRatingsDict[s.ClientId].Ratings.First().Ranking  - clientRatingsDict[s.ClientId].Ratings.Last().Ranking,
                     PerformanceHistory = clientRatingsDict[s.ClientId].Ratings.Count() > 1 ?
                     clientRatingsDict[s.ClientId].Ratings.Select(r => r.Performance).ToList() :
                     new List<double>() { clientRatingsDict[s.ClientId].Performance, clientRatingsDict[s.ClientId].Performance },
@@ -559,7 +560,7 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
 
             // update their performance 
 #if !DEBUG
-            if ((DateTime.UtcNow - attackerStats.LastStatHistoryUpdate).TotalMinutes >= 10)
+            if ((DateTime.UtcNow - attackerStats.LastStatHistoryUpdate).TotalMinutes >= 2.5)
 #endif
             {
                 await UpdateStatHistory(attacker, attackerStats);
@@ -620,16 +621,20 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                     ctx.Update(clientHistory);
                 }
 
+                var thirtyDaysAgo = DateTime.UtcNow.AddMonths(-1);
                 // get the client ranking for the current server
                 int individualClientRanking = await ctx.Set<EFRating>()
                     .Where(c => c.ServerId == clientStats.ServerId)
+                    .Where(r => r.RatingHistory.Client.Level != Player.Permission.Banned)
+                    .Where(r => r.ActivityAmount > 3600)
+                    .Where(r => r.RatingHistory.Client.LastConnection > thirtyDaysAgo)
                     .Where(c => c.RatingHistory.ClientId != client.ClientId)
                     .Where(r => r.Newest)
                     .Where(c => c.Performance > clientStats.Performance)
                     .CountAsync() + 1;
 
-                // limit max history per server to 30
-                if (clientHistory.Ratings.Count(r => r.ServerId == clientStats.ServerId) >= 30)
+                // limit max history per server to 40
+                if (clientHistory.Ratings.Count(r => r.ServerId == clientStats.ServerId) >= 40)
                 {
                     var ratingToRemove = clientHistory.Ratings.First(r => r.ServerId == clientStats.ServerId);
                     ctx.Entry(ratingToRemove).State = EntityState.Deleted;
@@ -653,6 +658,7 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                     Newest = true,
                     ServerId = clientStats.ServerId,
                     RatingHistoryId = clientHistory.RatingHistoryId,
+                    ActivityAmount = currentServerTotalPlaytime
                 });
 
                 // get other server stats
@@ -667,18 +673,18 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                 // weight the overall performance based on play time
                 var performanceAverage = clientStatsList.Sum(p => (p.Performance * p.TimePlayed)) / clientStatsList.Sum(p => p.TimePlayed);
 
-                var thirtyDaysAgo = DateTime.UtcNow.AddMonths(-1);
                 int overallClientRanking = await ctx.Set<EFRating>()
                     .Where(r => r.RatingHistory.Client.Level != Player.Permission.Banned)
-                    .Where(r => r.RatingHistory.Client.TotalConnectionTime > 3600)
+                    .Where(r => r.ActivityAmount > 3600)
                     .Where(r => r.RatingHistory.Client.LastConnection > thirtyDaysAgo)
                     .Where(r => r.RatingHistory.ClientId != client.ClientId)
                     .Where(r => r.ServerId == null)
                     .Where(r => r.Newest)
+                    .Where(r => r.Performance > performanceAverage)
                     .CountAsync() + 1;
 
-                // limit max average history to 30
-                if (clientHistory.Ratings.Count(r => r.ServerId == null) >= 30)
+                // limit max average history to 40
+                if (clientHistory.Ratings.Count(r => r.ServerId == null) >= 40)
                 {
                     var ratingToRemove = clientHistory.Ratings.First(r => r.ServerId == null);
                     ctx.Entry(ratingToRemove).State = EntityState.Deleted;
@@ -701,7 +707,8 @@ namespace IW4MAdmin.Plugins.Stats.Helpers
                     Performance = performanceAverage,
                     Ranking = overallClientRanking,
                     ServerId = null,
-                    RatingHistoryId = clientHistory.RatingHistoryId
+                    RatingHistoryId = clientHistory.RatingHistoryId,
+                    ActivityAmount = clientStatsList.Sum(s => s.TimePlayed)
                 });
 
                 await ctx.SaveChangesAsync();

Plugins/Stats/Models/EFRating.cs

@@ -25,5 +25,7 @@ namespace IW4MAdmin.Plugins.Stats.Models
         [Required]
         // indicates if the rating is the latest
         public bool Newest { get; set; }
+        [Required]
+        public int ActivityAmount { get; set; }
     }
 }

Plugins/Stats/Web/Controllers/StatsController.cs

@@ -16,7 +16,7 @@ namespace IW4MAdmin.Plugins.Stats.Web.Controllers
             ViewBag.Title = Utilities.CurrentLocalization.LocalizationIndex.Set["WEBFRONT_STATS_INDEX_TITLE"];
             ViewBag.Description = Utilities.CurrentLocalization.LocalizationIndex.Set["WEBFRONT_STATS_INDEX_DESC"];
 
-            return View("Index", await Plugin.Manager.GetTopStats(0, 25));
+            return View("Index", await Plugin.Manager.GetTopStats(0, 10));
         }
 
         [HttpGet]

Plugins/Stats/Web/Dtos/TopStatsInfo.cs

@@ -16,6 +16,7 @@ namespace IW4MAdmin.Plugins.Stats.Web.Dtos
         public string LastSeen { get; set; }
         public int Kills { get; set; }
         public int Deaths { get; set; }
+        public int RatingChange { get; set; }
         public List<double> PerformanceHistory { get; set; }
     }
 }

Plugins/Stats/Web/Views/Stats/_List.cshtml

@@ -29,7 +29,26 @@
 {
     <div class="row ml-0 mr-0 pt-2 pb-2">
         <div class="col-md-4  text-md-left text-center">
-            <h2 class="text-muted">#@stat.Ranking &mdash; @Html.ActionLink(stat.Name, "ProfileAsync", "Client", new { id = stat.ClientId })</h2>
+            <div class="h2 d-flex flex-row justify-content-center justify-content-md-start align-items-center">
+                <div class="text-muted pr-1">#@stat.Ranking</div>
+                @if (stat.RatingChange > 0)
+                {
+                    <div class="d-flex flex-column text-center">
+                        <div class="oi oi-caret-top text-success client-rating-change-up"></div>
+                        <div class="client-rating-change-amount text-success">@stat.RatingChange</div>
+                    </div>
+                }
+                @if (stat.RatingChange < 0)
+                {
+                    <div class="d-flex flex-column text-center">
+                        <div class="client-rating-change-amount client-rating-change-amount-down text-danger">@Math.Abs(stat.RatingChange)</div>
+                        <div class="oi oi-caret-bottom text-danger client-rating-change-down"></div>
+                    </div>
+                }
+                <span class="text-muted pl-1 pr-1" style="font-size: 1.25rem;">&mdash;</span>
+                @Html.ActionLink(stat.Name, "ProfileAsync", "Client", new { id = stat.ClientId })
+            </div>
+
             <span class="text-primary">@stat.Performance</span><span class="text-muted"> @loc["PLUGINS_STATS_COMMANDS_PERFORMANCE"]</span><br />
             <span class="text-primary">@stat.KDR</span><span class="text-muted"> @loc["PLUGINS_STATS_TEXT_KDR"]</span>
             <span class="text-primary">@stat.Kills</span><span class="text-muted"> @loc["PLUGINS_STATS_TEXT_KILLS"]</span>
@@ -46,4 +65,4 @@
             <img src="/images/icons/@rankIcon(stat.Performance)" />
         </div>
     </div>
-}
+}

SharedLibraryCore/Migrations/20180601172317_AddActivityAmount.Designer.cs

@@ -0,0 +1,504 @@
+// <auto-generated />
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Storage.Internal;
+using SharedLibraryCore.Database;
+using SharedLibraryCore.Objects;
+using System;
+
+namespace SharedLibraryCore.Migrations
+{
+    [DbContext(typeof(DatabaseContext))]
+    [Migration("20180601172317_AddActivityAmount")]
+    partial class AddActivityAmount
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.2-rtm-10011");
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFClientKill", b =>
+                {
+                    b.Property<long>("KillId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("AttackerId");
+
+                    b.Property<int>("Damage");
+
+                    b.Property<int?>("DeathOriginVector3Id");
+
+                    b.Property<int>("DeathType");
+
+                    b.Property<int>("HitLoc");
+
+                    b.Property<int?>("KillOriginVector3Id");
+
+                    b.Property<int>("Map");
+
+                    b.Property<int>("ServerId");
+
+                    b.Property<int>("VictimId");
+
+                    b.Property<int?>("ViewAnglesVector3Id");
+
+                    b.Property<int>("Weapon");
+
+                    b.Property<DateTime>("When");
+
+                    b.HasKey("KillId");
+
+                    b.HasIndex("AttackerId");
+
+                    b.HasIndex("DeathOriginVector3Id");
+
+                    b.HasIndex("KillOriginVector3Id");
+
+                    b.HasIndex("ServerId");
+
+                    b.HasIndex("VictimId");
+
+                    b.HasIndex("ViewAnglesVector3Id");
+
+                    b.ToTable("EFClientKills");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFClientMessage", b =>
+                {
+                    b.Property<long>("MessageId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("ClientId");
+
+                    b.Property<string>("Message");
+
+                    b.Property<int>("ServerId");
+
+                    b.Property<DateTime>("TimeSent");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFClientMessages");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFClientRatingHistory", b =>
+                {
+                    b.Property<int>("RatingHistoryId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("ClientId");
+
+                    b.HasKey("RatingHistoryId");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("EFClientRatingHistory");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFClientStatistics", b =>
+                {
+                    b.Property<int>("ClientId");
+
+                    b.Property<int>("ServerId");
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("Deaths");
+
+                    b.Property<double>("EloRating");
+
+                    b.Property<int>("Kills");
+
+                    b.Property<double>("MaxStrain");
+
+                    b.Property<double>("RollingWeightedKDR");
+
+                    b.Property<double>("SPM");
+
+                    b.Property<double>("Skill");
+
+                    b.Property<int>("TimePlayed");
+
+                    b.HasKey("ClientId", "ServerId");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFClientStatistics");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFHitLocationCount", b =>
+                {
+                    b.Property<int>("HitLocationCountId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("ClientId")
+                        .HasColumnName("EFClientStatistics_ClientId");
+
+                    b.Property<int>("HitCount");
+
+                    b.Property<float>("HitOffsetAverage");
+
+                    b.Property<int>("Location");
+
+                    b.Property<float>("MaxAngleDistance");
+
+                    b.Property<int>("ServerId")
+                        .HasColumnName("EFClientStatistics_ServerId");
+
+                    b.HasKey("HitLocationCountId");
+
+                    b.HasIndex("ServerId");
+
+                    b.HasIndex("ClientId", "ServerId");
+
+                    b.ToTable("EFHitLocationCounts");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFRating", b =>
+                {
+                    b.Property<int>("RatingId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("ActivityAmount");
+
+                    b.Property<bool>("Newest");
+
+                    b.Property<double>("Performance");
+
+                    b.Property<int>("Ranking");
+
+                    b.Property<int>("RatingHistoryId");
+
+                    b.Property<int?>("ServerId");
+
+                    b.HasKey("RatingId");
+
+                    b.HasIndex("RatingHistoryId");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFRating");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFServer", b =>
+                {
+                    b.Property<int>("ServerId");
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("Port");
+
+                    b.HasKey("ServerId");
+
+                    b.ToTable("EFServers");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFServerStatistics", b =>
+                {
+                    b.Property<int>("StatisticId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("ServerId");
+
+                    b.Property<long>("TotalKills");
+
+                    b.Property<long>("TotalPlayTime");
+
+                    b.HasKey("StatisticId");
+
+                    b.HasIndex("ServerId");
+
+                    b.ToTable("EFServerStatistics");
+                });
+
+            modelBuilder.Entity("SharedLibraryCore.Database.Models.EFAlias", b =>
+                {
+                    b.Property<int>("AliasId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<DateTime>("DateAdded");
+
+                    b.Property<int>("IPAddress");
+
+                    b.Property<int>("LinkId");
+
+                    b.Property<string>("Name")
+                        .IsRequired();
+
+                    b.HasKey("AliasId");
+
+                    b.HasIndex("LinkId");
+
+                    b.ToTable("EFAlias");
+                });
+
+            modelBuilder.Entity("SharedLibraryCore.Database.Models.EFAliasLink", b =>
+                {
+                    b.Property<int>("AliasLinkId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.HasKey("AliasLinkId");
+
+                    b.ToTable("EFAliasLinks");
+                });
+
+            modelBuilder.Entity("SharedLibraryCore.Database.Models.EFClient", b =>
+                {
+                    b.Property<int>("ClientId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("AliasLinkId");
+
+                    b.Property<int>("Connections");
+
+                    b.Property<int>("CurrentAliasId");
+
+                    b.Property<DateTime>("FirstConnection");
+
+                    b.Property<DateTime>("LastConnection");
+
+                    b.Property<int>("Level");
+
+                    b.Property<bool>("Masked");
+
+                    b.Property<long>("NetworkId");
+
+                    b.Property<string>("Password");
+
+                    b.Property<string>("PasswordSalt");
+
+                    b.Property<int>("TotalConnectionTime");
+
+                    b.HasKey("ClientId");
+
+                    b.HasIndex("AliasLinkId");
+
+                    b.HasIndex("CurrentAliasId");
+
+                    b.HasIndex("NetworkId")
+                        .IsUnique();
+
+                    b.ToTable("EFClients");
+                });
+
+            modelBuilder.Entity("SharedLibraryCore.Database.Models.EFPenalty", b =>
+                {
+                    b.Property<int>("PenaltyId")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<string>("AutomatedOffense");
+
+                    b.Property<DateTime>("Expires");
+
+                    b.Property<int>("LinkId");
+
+                    b.Property<int>("OffenderId");
+
+                    b.Property<string>("Offense")
+                        .IsRequired();
+
+                    b.Property<int>("PunisherId");
+
+                    b.Property<int>("Type");
+
+                    b.Property<DateTime>("When");
+
+                    b.HasKey("PenaltyId");
+
+                    b.HasIndex("LinkId");
+
+                    b.HasIndex("OffenderId");
+
+                    b.HasIndex("PunisherId");
+
+                    b.ToTable("EFPenalties");
+                });
+
+            modelBuilder.Entity("SharedLibraryCore.Helpers.Vector3", b =>
+                {
+                    b.Property<int>("Vector3Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<float>("X");
+
+                    b.Property<float>("Y");
+
+                    b.Property<float>("Z");
+
+                    b.HasKey("Vector3Id");
+
+                    b.ToTable("Vector3");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFClientKill", b =>
+                {
+                    b.HasOne("SharedLibraryCore.Database.Models.EFClient", "Attacker")
+                        .WithMany()
+                        .HasForeignKey("AttackerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("SharedLibraryCore.Helpers.Vector3", "DeathOrigin")
+                        .WithMany()
+                        .HasForeignKey("DeathOriginVector3Id");
+
+                    b.HasOne("SharedLibraryCore.Helpers.Vector3", "KillOrigin")
+                        .WithMany()
+                        .HasForeignKey("KillOriginVector3Id");
+
+                    b.HasOne("IW4MAdmin.Plugins.Stats.Models.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("SharedLibraryCore.Database.Models.EFClient", "Victim")
+                        .WithMany()
+                        .HasForeignKey("VictimId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("SharedLibraryCore.Helpers.Vector3", "ViewAngles")
+                        .WithMany()
+                        .HasForeignKey("ViewAnglesVector3Id");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFClientMessage", b =>
+                {
+                    b.HasOne("SharedLibraryCore.Database.Models.EFClient", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("IW4MAdmin.Plugins.Stats.Models.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFClientRatingHistory", b =>
+                {
+                    b.HasOne("SharedLibraryCore.Database.Models.EFClient", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFClientStatistics", b =>
+                {
+                    b.HasOne("SharedLibraryCore.Database.Models.EFClient", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("IW4MAdmin.Plugins.Stats.Models.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFHitLocationCount", b =>
+                {
+                    b.HasOne("SharedLibraryCore.Database.Models.EFClient", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("IW4MAdmin.Plugins.Stats.Models.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("IW4MAdmin.Plugins.Stats.Models.EFClientStatistics")
+                        .WithMany("HitLocations")
+                        .HasForeignKey("ClientId", "ServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFRating", b =>
+                {
+                    b.HasOne("IW4MAdmin.Plugins.Stats.Models.EFClientRatingHistory", "RatingHistory")
+                        .WithMany("Ratings")
+                        .HasForeignKey("RatingHistoryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("IW4MAdmin.Plugins.Stats.Models.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId");
+                });
+
+            modelBuilder.Entity("IW4MAdmin.Plugins.Stats.Models.EFServerStatistics", b =>
+                {
+                    b.HasOne("IW4MAdmin.Plugins.Stats.Models.EFServer", "Server")
+                        .WithMany()
+                        .HasForeignKey("ServerId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("SharedLibraryCore.Database.Models.EFAlias", b =>
+                {
+                    b.HasOne("SharedLibraryCore.Database.Models.EFAliasLink", "Link")
+                        .WithMany("Children")
+                        .HasForeignKey("LinkId")
+                        .OnDelete(DeleteBehavior.Restrict);
+                });
+
+            modelBuilder.Entity("SharedLibraryCore.Database.Models.EFClient", b =>
+                {
+                    b.HasOne("SharedLibraryCore.Database.Models.EFAliasLink", "AliasLink")
+                        .WithMany()
+                        .HasForeignKey("AliasLinkId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("SharedLibraryCore.Database.Models.EFAlias", "CurrentAlias")
+                        .WithMany()
+                        .HasForeignKey("CurrentAliasId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("SharedLibraryCore.Database.Models.EFPenalty", b =>
+                {
+                    b.HasOne("SharedLibraryCore.Database.Models.EFAliasLink", "Link")
+                        .WithMany("ReceivedPenalties")
+                        .HasForeignKey("LinkId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("SharedLibraryCore.Database.Models.EFClient", "Offender")
+                        .WithMany("ReceivedPenalties")
+                        .HasForeignKey("OffenderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SharedLibraryCore.Database.Models.EFClient", "Punisher")
+                        .WithMany("AdministeredPenalties")
+                        .HasForeignKey("PunisherId")
+                        .OnDelete(DeleteBehavior.Restrict);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

SharedLibraryCore/Migrations/20180601172317_AddActivityAmount.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace SharedLibraryCore.Migrations
+{
+    public partial class AddActivityAmount : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "ActivityAmount",
+                table: "EFRating",
+                nullable: false,
+                defaultValue: 0);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ActivityAmount",
+                table: "EFRating");
+        }
+    }
+}

SharedLibraryCore/Migrations/DatabaseContextModelSnapshot.cs

@@ -176,6 +176,8 @@ namespace SharedLibraryCore.Migrations
 
                     b.Property<bool>("Active");
 
+                    b.Property<int>("ActivityAmount");
+
                     b.Property<bool>("Newest");
 
                     b.Property<double>("Performance");

WebfrontCore/WebfrontCore.csproj

@@ -30,6 +30,7 @@
     <Content Remove="bower.json" />
     <Content Remove="bundleconfig.json" />
     <Content Remove="compilerconfig.json" />
+    <Content Remove="Views\Plugins\Stats\_RatingHistory.cshtml" />
   </ItemGroup>
 
   <ItemGroup>

WebfrontCore/wwwroot/css/bootstrap-custom.scss

@@ -192,5 +192,12 @@ select {
 }
 
 .client-rating-icon {
+}
 
-}
+.client-rating-change-up, .client-rating-change-down {
+    font-size: 0.75rem;
+}
+
+.client-rating-change-amount {
+    font-size: 1rem;
+}

WebfrontCore/wwwroot/js/loader.js

@@ -1,12 +1,14 @@
-let loaderOffset = 25;
-let loadCount = 25;
+let loaderOffset = 10;
+let loadCount = 10;
 let isLoaderLoading = false;
 let loadUri = '';
 let loaderResponseId = '';
 
-function initLoader(location, loaderId) {
+function initLoader(location, loaderId, count = 10) {
     loadUri = location;
     loaderResponseId = loaderId;
+    loadCount = count;
+    loaderOffset = count;
     setupListeners();
 }
 

WebfrontCore/wwwroot/js/stats.js

@@ -2,9 +2,24 @@
     const data = $('#' + id).data('history');
     let fixedData = [];
     data.forEach(function (item, i) {
-        fixedData[i] = { x: i, y: item };
+        fixedData[i] = { x: i, y: Math.floor(item) };
     });
 
+    let dataMin = Math.min(...data);
+    const dataMax = Math.max(...data);
+
+    if (dataMax - dataMin === 0) {
+        dataMin = 0;
+    }
+
+    const padding = (dataMax - dataMin) * 0.075;
+    const min = Math.max(0, dataMin - padding);
+    const max = dataMax + padding;
+    let interval = Math.floor((max - min) / 2);
+
+    if (interval < 1)
+        interval = 1;
+
     return new CanvasJS.Chart(id, {
         backgroundColor: 'transparent',
         height: height,
@@ -12,37 +27,36 @@
         animationEnabled: false,
         toolTip: {
             contentFormatter: function (e) {
-                return e.entries[0].dataPoint.y;
+                return Math.round(e.entries[0].dataPoint.y, 1);
             }
         },
-        axisX: {
-            interval: 1,
-            gridThickness: 0,
-            lineThickness: 0,
-            tickThickness: 0,
-            margin: 0,
-            valueFormatString: " "
+        title: {
+            text: "Performance History",
+            fontSize: 14
         },
-        axisY: {
+        axisX: {
             gridThickness: 0,
             lineThickness: 0,
             tickThickness: 0,
-            minimum: Math.min(...data) - Math.min(...data) * 0.075,
-            maximum: Math.max(...data) + Math.max(...data) * 0.075,
             margin: 0,
             valueFormatString: " ",
-            labelMaxWidth: 0
+        },
+        axisY: {
+            labelFontSize: 12,
+            interval: interval,
+            gridThickness: 0,
+            lineThickness: 0.5,
+            valueFormatString: "#,##0",
+            minimum: min,
+            maximum: max
         },
         legend: {
-            maxWidth: 0,
-            maxHeight: 0,
             dockInsidePlotArea: true
         },
         data: [{
-            showInLegend: false,
             type: "splineArea",
             color: 'rgba(0, 122, 204, 0.25)',
-            markerSize: 0,
+            markerSize: 3.5,
             dataPoints: fixedData
         }]
     });