AuctionTracker/AuctionTracker/Program.cs

using System;
using BlizzSharp;
using AuctionTracker.Push;
using BlizzSharp.Data;
using System.Linq;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Text;
using System.Reflection;
using log4net;
using System.IO;
using log4net.Config;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Configuration.FileExtensions;
using Microsoft.Extensions.Configuration.Json;
using ServiceStack.Redis;
using ServiceStack.Redis.Generic;

namespace AuctionTracker
{
    class Program
    {
        const string SHORT_DURATION = "SHORT";
        private static BlizzSharpClient _client;
        private static PushClient _pushClient;
        private static IEnumerable<Auction> lastAuctions;
        private static IConfiguration _configuration;
        private static ILog _logger;
        private static string _redisPass;

        private static RedisManagerPool _redisPool;
        private static string _character;
        private static string _locale;
        private static string _realm;

        private static string FormatCurrency(long full)
        {
            long gold = full / 10000;
            long silver = (full - (gold*10000)) / 100;
            long copper = (full - (gold*10000) - (silver * 100));
            return $"{gold}G {silver}S {copper}C";
        }
        private static async Task RunUpdate()
        {
            _logger.Info($"Running Update for {_character} on {_realm}");
            AuctionResponse response = await _client.GetAuctionsAsync(_realm, _locale);
            IEnumerable<Auction> auctions = response.Auctions.Where(a => a.Owner == _character);
            if(lastAuctions != null)
            {
                HashSet<Auction> expiredAuctions = new HashSet<Auction>();
                bool removedFound = false;
                foreach(Auction a in lastAuctions)
                {
                    if(!auctions.Any(b => b.Id == a.Id))
                    {
                        //the auction is now gone, but why?
                        Item item = await _client.GetItemInfoAsync(a.Item, _locale);
                        if(a.TimeLeft == SHORT_DURATION)
                        {
                            //the auction probably expired
                            expiredAuctions.Add(a);
                        }
                        else
                        {
                            //the auction was sold
                            await _pushClient.SendNotification($"Your Auction of {a.quantity}x {item.Name} was sold for {FormatCurrency(a.Buyout)}.", "cashregister");
                        }
                        removedFound = true;
                    }
                }
                if(!removedFound)
                {
                    _logger.Info("No Expired/Sold Auctions found");
                }
                if(expiredAuctions.Any())
                {
                    StringBuilder sb = new StringBuilder();
                    foreach(Auction a in expiredAuctions)
                    {
                        string name = (await _client.GetItemInfoAsync(a.Item, _locale)).Name;
                        sb.AppendLine($"{a.quantity}x {name}");
                    }
                    await _pushClient.SendNotification($"Your Auctions have expired:\n{sb.ToString()}", "none");
                }
            }
            lastAuctions = auctions;
            //update redis database
            using (IRedisClient client = _redisPool.GetClient())
            {
                var auctionClient = client.As<RedisAuctionSnapshot>();
                foreach(Auction auction in auctions)
                {
                    RedisAuctionSnapshot snapshot = await RedisAuctionSnapshot.FromAuctionClientAsync(auction, _client, _locale);
                    auctionClient.Store(snapshot, TimeSpan.FromMinutes(20d));
                }
            }
            //retrieving stuff
            _logger.Info("Retrieving stored values");
            using (IRedisClient client = _redisPool.GetClient())
            {
                var auctionClient = client.As<RedisAuctionSnapshot>();
                foreach(RedisAuctionSnapshot item in auctionClient.GetAll())
                {
                    _logger.Info(item.Name);
                }
            }
        }
        static async Task Main(string[] args)
        {
            //configure logging
            var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
            XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
            _logger = LogManager.GetLogger(typeof(Program));
            
            _logger.Info("Started AuctionTracker, initializing configuration");
            var builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json");
            _configuration = builder.Build();
            _character = _configuration["character"];
            _locale = _configuration["locale"];
            _realm = _configuration["realm"];
            _redisPass = _configuration["redisPassword"];
            _logger.Info("Creating Clients");
            _client = new BlizzSharpClient($"{_configuration["blizzardApiKey"]}");
            _pushClient = new PushClient($"{_configuration["pushoverSecretKey"]}", $"{_configuration["pushoverUserKey"]}");
            _logger.Info("Initializing redis pool");
            if(string.IsNullOrEmpty(_redisPass))
            {
                _redisPool = new RedisManagerPool("localhost:6379");
            }
            else
            {
                _redisPool = new RedisManagerPool($"{_redisPass}@localhost:6379");
            }
            
            _logger.Info("AuctionTracker started, entering loop");

            while(true)
            {
                await RunUpdate();
                System.Threading.Thread.Sleep(TimeSpan.FromMinutes(15d));
            }
            
        }
    }
}