public bool AddQueue()
{
DSWaitingSystem dswaitingSystem = this.service.DSWaitingSystem;
if (dswaitingSystem != null)
{
string argString = base.Operation.GetArgString(0, "");
if (argString == "reset")
{
string @string = FeatureMatrix.GetString("DSQuestSetting");
using (IEnumerator <string> enumerator = (from q in @string.Split(new char[]
{
','
})
where q != ""
select q).GetEnumerator())
{
while (enumerator.MoveNext())
{
string text = enumerator.Current;
dswaitingSystem.AddWaitingQueue(text.Trim(), -1, true);
}
return(true);
}
}
int argInt = base.Operation.GetArgInt(1, -1);
dswaitingSystem.AddWaitingQueue(argString, argInt, true);
}
else
{
DSService.RequestDSBossOperation(base.Operation);
}
return(true);
}
public void GetHourDataPointFailInvalidDataPointList()
{
var sut = new DSService();
var ex = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.GetForecastForHour(12, null));
Assert.Equal("InvalidHDataPointsParameter", ex.Result.ParamName);
}
public bool RemoveQueue()
{
DSWaitingSystem dswaitingSystem = this.service.DSWaitingSystem;
if (dswaitingSystem != null)
{
string argString = base.Operation.GetArgString(0, "");
if (argString == "all")
{
using (List <KeyValuePair <string, DSWaitingQueue> > .Enumerator enumerator = dswaitingSystem.QueueDict.ToList <KeyValuePair <string, DSWaitingQueue> >().GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <string, DSWaitingQueue> keyValuePair = enumerator.Current;
dswaitingSystem.RemoveWaitingQueue(keyValuePair.Key);
}
return(true);
}
}
dswaitingSystem.RemoveWaitingQueue(argString);
}
else
{
DSService.RequestDSBossOperation(base.Operation);
}
return(true);
}
public void GetWeatherDataInvalidParameters()
{
var sut = new DSService();
var ex = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.GetWeather(null, null, DateTime.MinValue));
Assert.Equal("InvalidParameters", ex.Result.ParamName);
}
public bool AddDummy()
{
DSWaitingSystem dswaitingSystem = this.service.DSWaitingSystem;
if (dswaitingSystem != null)
{
string argString = base.Operation.GetArgString(0, "");
List <DSPlayerInfo> list = new List <DSPlayerInfo>();
int num = 1;
for (;;)
{
int argInt = base.Operation.GetArgInt(num, -1);
if (argInt <= 0)
{
break;
}
list.Add(new DSPlayerInfo((long)_CheatCommandProcessor.DummyClientID, -1L, argInt));
_CheatCommandProcessor.DummyClientID--;
num++;
}
dswaitingSystem.Register(argString, list, -1L, -1L, true, false);
this.DSState();
}
else
{
DSService.RequestDSBossOperation(base.Operation);
}
return(true);
}
public bool SinkShip()
{
if (this.service.DSWaitingSystem == null)
{
DSService.RequestDSBossOperation(base.Operation);
}
return(true);
}
public DSEntityMakerSystem(DSService parent)
{
this.NormalRaidResorcePoint = FeatureMatrix.GetInteger("DSNormalRaidResorcePoint");
this.GaiantRaidResorcePoint = FeatureMatrix.GetInteger("DSGiantRaidResorcePoint");
this.PvpResorcePoint = FeatureMatrix.GetInteger("DSPvpResorcePoint");
this.DSServiceInfoDic = new Dictionary <int, DSServiceInfo>();
this.DSEntityMakerList = new LinkedList <DSEntityMakerQueue>();
this.Parent = parent;
this.startID = 0;
DSServiceInfo.SetDSResorcePoint(this.NormalRaidResorcePoint, this.GaiantRaidResorcePoint, this.PvpResorcePoint);
}
public bool DSState()
{
DSWaitingSystem dswaitingSystem = this.service.DSWaitingSystem;
if (dswaitingSystem != null)
{
IEntityProxy frontendConn = this.service.Connect(this.service.DSServiceEntity, new Location(base.Operation.FrontendID, "FrontendServiceCore.FrontendService"));
frontendConn.SendConsole(dswaitingSystem.ToString(), new object[0]);
}
else
{
DSService.RequestDSBossOperation(base.Operation);
}
return(true);
}
public async Task NoonHourDataPointIsRetrieved()
{
int noonValue = await Task.FromResult(12);
var dataPoints = new List <HourDataPoint>();
var jsonString = File.ReadAllText(@".\TestData\HoursDataPointList.json");
dataPoints = JsonSerializer.Deserialize <List <HourDataPoint> >(jsonString);
var sut = new DSService();
var result = sut.GetForecastForHour(12, dataPoints);
var dataPoint = result.Result;
Assert.IsType <HourDataPoint>(dataPoint);
Assert.Equal(dataPoint.Time.Hour, noonValue);
}
public RegisterDSEntityProcessor(DSService service, RegisterDSEntity op) : base(op)
{
this.service = service;
}
public static void Main(string[] args)
{
var settingPath = args.Where(p => p.EndsWith(".json", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (string.IsNullOrEmpty(settingPath))
{
settingPath = "Settings.json";
}
try
{
if (!File.Exists(settingPath))
{
Utils.Log("Settings not found: {0}", settingPath);
return;
}
string json = File.ReadAllText(settingPath);
var settings = Utils.deserializeJSON <Settings>(json);
Utils.logLocation = settings.logLocation;
DSService service = new DSService(settings.synology);
Utils.Log("Signing in to DownloadStation:");
if (service.SignIn())
{
Utils.Log("Getting Task list...");
var tasks = service.GetTasks().OrderBy(x => x.title);
var tasksToDelete = tasks.Where(x => isDeletable(x, settings.synology))
.OrderBy(x => x.additional.detail.create_time)
.ToList();
var tasksToKeep = tasks.Except(tasksToDelete)
.OrderBy(x => x.additional.detail.create_time)
.ToList();
if (tasksToKeep.Any())
{
Utils.Log("Tasks to Keep:");
foreach (var task in tasksToKeep)
{
Utils.Log($" - {task.title}");
}
}
if (tasksToDelete.Any())
{
Utils.Log("Tasks to delete:");
foreach (var task in tasksToDelete)
{
Utils.Log($" - {task.title}");
}
service.DeleteTask(tasksToDelete.Select(x => x.id).ToArray());
Utils.SendAlertEmail(settings.email, tasksToDelete);
}
else
{
Utils.Log("No tasks to delete");
}
}
else
{
Utils.Log("Login failed.");
}
}
catch (Exception ex)
{
Utils.Log("Error initialising. {0}", ex);
}
}
public QueryDSServiceInfoProcessor(DSService service, QueryDSServiceInfo op) : base(op)
{
this.service = service;
}
public QueryDSQuestListProcessor(DSService service, QueryDSQuestList op) : base(op)
{
this.service = service;
}
public RegisterDSServiceInfoProcessor(DSService service, RegisterDSServiceInfo op) : base(op)
{
this.service = service;
}
public QueryPvpDSInfosProcessor(DSService service, QueryPvpDSInfos op) : base(op)
{
this.service = service;
}
public RequestMakeDSEntityProcessor(DSService service, RequestMakeDSEntity op) : base(op)
{
this.service = service;
}
public RPCServiceProxy(string uri, int links = 4, int retry = 5, int timeOut = 10 * 1000)
{
ExceptionCollector.OnErr += ExceptionCollector_OnErr;
_serviceConsumer = new ServiceConsumer(new Uri(uri), links, retry, timeOut);
_DS = new DSService(_serviceConsumer);
}
public UpdateDSShipInfoProcessor(DSService sv, UpdateDSShipInfo op) : base(op)
{
this.service = sv;
}
public UpdateDSPlayerInfoProcessor(DSService service, UpdateDSPlayerInfo op) : base(op)
{
this.service = service;
}
public UnregisterDSPlayerProcessor(DSService sv, UnregisterDSPlayer op) : base(op)
{
this.service = sv;
}
public bool RemoveDummy()
{
DSWaitingSystem dswaitingSystem = this.service.DSWaitingSystem;
if (dswaitingSystem != null)
{
string argString = base.Operation.GetArgString(0, "");
DSWaitingQueue dswaitingQueue = dswaitingSystem.QueueDict.TryGetValue(argString);
if (dswaitingQueue != null)
{
int num = base.Operation.GetArgInt(1, 0);
int num2 = 0;
if (num >= 0)
{
using (LinkedList <DSWaitingParty> .Enumerator enumerator = dswaitingQueue.WaitingParties.GetEnumerator())
{
while (enumerator.MoveNext())
{
DSWaitingParty dswaitingParty = enumerator.Current;
foreach (KeyValuePair <long, DSPlayer> keyValuePair in dswaitingParty.Members)
{
if (keyValuePair.Key < 0L)
{
if (num2 == num)
{
dswaitingSystem.Unregister(keyValuePair.Key, false);
this.DSState();
return(true);
}
num2++;
}
}
}
return(true);
}
}
num = -1 - num;
foreach (DSShip dsship in dswaitingQueue.Ships)
{
foreach (KeyValuePair <long, DSPlayer> keyValuePair2 in dsship.Players)
{
if (keyValuePair2.Key < 0L)
{
if (num2 == num)
{
dswaitingSystem.Unregister(keyValuePair2.Key, false);
this.DSState();
return(true);
}
num2++;
}
}
}
return(true);
}
}
else
{
DSService.RequestDSBossOperation(base.Operation);
}
return(true);
}
public LaunchDSProcessor(DSService service, LaunchDS op) : base(op)
{
this.service = service;
}
public _CheatCommandProcessor(DSService service, _CheatCommand op) : base(op)
{
this.service = service;
}
public DSCheatToggleProcessor(DSService service, DSCheatToggle op) : base(op)
{
this.service = service;
}
public RegisterDSPartyProcessor(DSService sv, RegisterDSParty op) : base(op)
{
this.service = sv;
}
public CancelMakeDSEntityProcessor(DSService service, CancelMakeDSEntity op) : base(op)
{
this.service = service;
}
/// <summary>
/// Иницилизируем список DSService'ов беря информацию из файла Configuration.cfg
/// </summary>
void InitDataServers()
{
_dsServiceDictionary = new Dictionary<ushort, DSService>();
XDocument configurationFileXDocument = XDocument.Load(HMI_Settings.PathToConfigurationFile);
var dsConfigXElementList = configurationFileXDocument.Element("Project").Element("Configuration").Elements("Object");
foreach (var dsConfigXElement in dsConfigXElementList)
{
try
{
UInt16 dsGuid = UInt16.Parse(dsConfigXElement.Attribute("UniDS_GUID").Value);
string ipAddress = dsConfigXElement.Element("DSAccessInfo").Element("binding").Element("IPAddress").Attribute("value").Value;
string port = dsConfigXElement.Element("DSAccessInfo").Element("binding").Element("Port").Attribute("value").Value;
var dsService = new DSService(dsGuid, ipAddress, port);
dsService.TagsValuesUpdated += TagsValuesUpdated;
_dsServiceDictionary.Add(dsGuid, dsService);
}
catch (Exception ex)
{
Log.WriteErrorMessage("DataServersCollector:InitDataServers : " + ex.Message);
}
}
}
