LogProcessingGate/LogScoringGate.cs - master - AstroJohn/MailRobot

LogProcessingGate/LogScoringGate.cs
393 строки10 KB
AstroJohn
Delete log menu
05 авг 2026, 21:25
05 авг 2026, 21:255efcbdd
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Common;
using DbContext.Models;
using LogProcessingModels.Configuration;
using LogProcessingModels.Parsing;
using LogProcessingModels.PrefixResolving;
using LogProcessingModels.Scoring;
using LogScoring;

namespace LogProcessingGate
{
	public class LogScoringGate: ContestProcessorSelectorBase<ILogScoring>
	{
		protected override ILogScoring DefaultProcessor => null;

		public event KeepInTouchEventHandler KeepInTouch;

		protected string ConnectionString { get; }

		protected ILogScoring LogScoring { get; }

		public bool IsInitialized => LogScoring != null;

		public LogScoringGate(clsChecker_Parameters parameters, IPrefixResolver prefixResolver, string connectionString, Action<string> writeLog) : base(parameters)
		{
			ConnectionString = connectionString;

			var types = GetProcessors(parameters.ParserParameters.ContestName);

            if (types == null || !types.Any())
                throw new Exception($"Не найден метод расчета результата для контеста {parameters.ParserParameters.ContestName}");

            LogScoring = (ILogScoring)Activator.CreateInstance(types.First());

			LogScoring.Initialize
			(
				parameters.ParserParameters.DateStart,
				parameters.ParserParameters.DateEnd,
				parameters.ParserParameters.UBNLinkTemplate,
				prefixResolver,
				connectionString,
				writeLog
			);
		}

		public Log ConvertLog(ParsedLog parsedLog, string fileName = null, long? fileSize = null, DateTime? lastAccessDate = null)
		{

			string operators;
			string address;
			string name;
			string soapbox;
			string equipment;
			DateTime? contestDate;

			var createdBy = parsedLog.GetHeaderValue("CREATED-BY");

			if (parsedLog.Format == LOG_FORMAT.ERMAK)
			{
				operators = parsedLog.GetHeaderValue_All("OPERATOR");
				address = parsedLog.GetHeaderValue_All("ADDRESS");
				name = parsedLog.GetHeaderValue("NAME");
				equipment = null;
				soapbox = parsedLog.GetHeaderValue("SOAPBOX");
				contestDate = null;
			}
			else // if (parsedLog.Format == LOG_FORMAT.EDI)
			{
				operators = parsedLog.GetHeaderValue_All("RCall") + ";" + parsedLog.GetHeaderValue("RName") + Environment.NewLine + parsedLog.GetHeaderValue_All("MOpe");
				address = parsedLog.GetHeaderValue_All("RAdr") + Environment.NewLine + parsedLog.GetHeaderValue("RPoCo") + Environment.NewLine + parsedLog.GetHeaderValue("RCity") + Environment.NewLine + parsedLog.GetHeaderValue("RCoun");
				name = parsedLog.GetHeaderValue("RName").Split(';')[0];
				equipment = GetEquipmenInfo(parsedLog);
				soapbox = null;
				contestDate = parsedLog.ContestDate;
			}

            string oblId = null;

            if
            (
                parsedLog.Callsign.IsRussianCallsign()
                && parsedLog.Location.IsRda()
            )
            {
                oblId = parsedLog.Location.Left(2);
            }

            var station = new LogFiles
			{
				Id = -1,
				Call = parsedLog.Callsign,
				CountryId = null,
				RegionId = oblId,
				TeamRegionId = parsedLog.TeamOblId,
				Operators = operators,
				Name = name,
				Address = address,
				CreatedBy = createdBy,
				Soapbox = soapbox,
				Разряд = null,
				ФИО = parsedLog.OblId,
				ГодРождения = null,
				Категория = null,
				Location = parsedLog.GridLocator,
				Email = parsedLog.EMail,
			};

			var category = new LogFilesCategory
			{
				Id = -1,
				Call = parsedLog.Callsign,
				FileName = Path.GetFileName(fileName),
				DateCreate = lastAccessDate,
				FileSize = Convert.ToInt32(fileSize),
				Category = parsedLog.Category,
				Band = parsedLog.Band,
				Equipment = equipment,
				Date = contestDate,
				Location = parsedLog.GridLocator
			};

			var log = new Log
			{
				Station = station,
				Category = category
			};

			var i = 0;
			foreach (var parsedQso in parsedLog.QSOs)
			{
				i++;
                if (parsedLog.Category.IsSwl())
                {
                    var swl = new Swls
                    {
                        Id         = i,
						SwlCall    = parsedLog.Callsign,
                        Call1      = parsedQso.CallSign,
                        Call2      = parsedQso.Stn,
                        Band       = parsedQso.Band,
                        Mode       = parsedQso.Mode,
                        Time       = parsedQso.Time.ToString("HHmm"),
                        NrSent     = parsedQso.SentNr,
                        NrRcvd     = parsedQso.RcvdNr,
                        ErrType    = null,
                        ErrPar     = null,
                        CountryId1 = null,
                        RegionId1  = null,
                        CountryId2 = null,
                        RegionId2  = null,
						Mult11     = null,
                        Mult12     = null,
                        Mult13     = null,
                        Mult21     = null,
                        Mult22     = null,
                        Mult23     = null,
                        Freq       = parsedQso.Freq.ToString("D"),
                        Date       = parsedQso.Time
                    };

                    log.Swls.Add(swl);
                }
                else
                {
                    var qso = new Qsos
				    {
					    Id = i,
					    Call1 = parsedLog.Callsign,
					    Call2 = parsedQso.Stn,
					    Band = parsedQso.Band,
					    Mode = parsedQso.Mode,
					    Time = parsedQso.Time.ToString("HHmm"),
					    NrSent = parsedQso.SentNr,
					    NrRcvd = parsedQso.RcvdNr,
					    ErrType = null,
					    ErrPar = null,
					    IsLogRcvd = null,
					    CountryId = null,
					    RegionId = null,
					    DistrictId = null,
					    Id2 = null,
					    Freq = parsedQso.Freq.ToString("D"),
					    Date = parsedQso.Time
				    };

				    log.Qsos.Add(qso);
                }

			}

            return log;
		}

		public IEnumerable<LogFilesBandResults> GetScore(ParsedLog parsedLog)
		{
			var log = ConvertLog(parsedLog);
			return GetScore(log, true, ResultsType.Claimed);
		}

        public string GetOblast(string callsign)
        {
            return LogScoring.GetOblast(callsign);
        }

        public string GetTeam(string callsign)
        {
            return LogScoring.GetTeam(callsign);
        }

		public IEnumerable<LogFilesBandResults> GetScore(Log log, bool resolvePrefixes, int resultsType)
		{
			return LogScoring.ScoreLog(log, resolvePrefixes, resultsType);
		}

		public string GetTextScore(Log log, IEnumerable<LogFilesBandResults> scores)
		{
			return LogScoring.GetTextScore(log, scores);
		}

		public string GetTextScore(Log log, bool resolvePrefixes, int resultsType)
		{
			var scores = LogScoring.ScoreLog(log, resolvePrefixes, resultsType);
			return LogScoring.GetTextScore(log, scores);
		}

		public string GetTextScore(ParsedLog parsedLog, bool resolvePrefixes, int resultsType)
		{
			var log = ConvertLog(parsedLog);
			var logScore = GetScore(log, resolvePrefixes, resultsType);
			return LogScoring.GetTextScore(log, logScore);
		}

		public bool SaveLog(Log log, string category, string band, DateTime? contestDate, out string errorMessage)
		{
			return LogScoring.SaveLog(log, category, band, contestDate, out errorMessage);
		}

		public DateTime? GetLogFileInfo(string fileName)
		{
			return LogScoring.GetLogFileInfo(fileName);
		}

		public static string GetEquipmenInfo(ParsedLog log)
		{
			var res = string.Empty;

			var antH = log.GetHeaderValue("SAntH").Split(';');

			var tx = log.GetHeaderValue("STXEq").Trim();

			var pwr = log.GetHeaderValue("SPowe").ToUpper().Trim();

			if (!pwr.Contains("KW"))
			{
				if (int.TryParse(pwr.Replace("W", ""), out var power))
					pwr = $"{power:D} W";
			}
			else
				pwr = string.Empty;

			var rx = log.GetHeaderValue("SRXEq").Trim();

			if (rx == tx)
				rx = string.Empty;
			else if (rx != string.Empty)
				rx = "RX: " + rx;

			if (tx != string.Empty)
				tx = "TX: " + tx;

			var ant = log.GetHeaderValue("SAnte").Trim();
			var asl = string.Empty;
			var agl = string.Empty;

			if (antH.Length == 2)
			{
				asl = antH[1].Trim();
				if (asl != string.Empty)
					asl = asl + " m ASL";

				agl = antH[0].Trim();
				if (agl != string.Empty)
					agl = agl + " m AGL";
			}

			if (ant != string.Empty)
			{
				ant = "ANT: " + ant + " " + asl + " " + agl;
				ant = ant.Trim();
			}

			if (tx != string.Empty)
				res = res + tx;

			if (pwr != string.Empty)
			{
				res = res + " " + pwr;
				res = res + Environment.NewLine;
			}
			else if (pwr != string.Empty)
				res = res + "PWR: " + pwr + Environment.NewLine;

			if (rx != string.Empty)
				res = res + rx + Environment.NewLine;

			if (ant != string.Empty)
				res = res + ant;

			return res.Trim();
		}

		public void RescoreResults(bool localOnly)
		{
			LogScoring.KeepInTouch += KeepInTouch;
			try
			{
				LogScoring.RescoreResults(localOnly);
			}
			catch (Exception ex)
			{
				// ReSharper disable once PossibleIntendedRethrow
				throw ex;
			}
			finally
			{
				LogScoring.KeepInTouch -= KeepInTouch;
			}
		}

		public void PrepareResults()
		{
			LogScoring.KeepInTouch += KeepInTouch;
			try
			{
				LogScoring.PrepareResults();
			}
			catch (Exception ex)
			{
				// ReSharper disable once PossibleIntendedRethrow
				throw ex;
			}
			finally
			{
				LogScoring.KeepInTouch -= KeepInTouch;
			}
		}

        public void ClearDatabase(bool makeEmpty)
        {
            LogScoring.KeepInTouch += KeepInTouch;
            try
            {
                LogScoring.ClearDatabase(makeEmpty);
            }
            catch (Exception ex)
            {
                // ReSharper disable once PossibleIntendedRethrow
                throw ex;
            }
            finally
            {
                LogScoring.KeepInTouch -= KeepInTouch;
            }
        }

        public string DeleteLog(string callsign)
        {
            string errorMessage;

            LogScoring.KeepInTouch += KeepInTouch;

            try
            {
                LogScoring.DeleteLog(callsign, null, null, null, out errorMessage);
            }
            catch (Exception ex)
            {
                // ReSharper disable once PossibleIntendedRethrow
                throw ex;
            }
            finally
            {
                LogScoring.KeepInTouch -= KeepInTouch;
            }

            return errorMessage;
        }

    }
}