public SlotModel Read(string filePath, string name, ClientSettings settings)
{
var slots = new List<SlotData>();
var serializer = new XmlFileSerializer<SlotSummary>();
try
{
slots = serializer.Deserialize(filePath).Slots;
}
catch (Exception ex)
{
_logger.ErrorFormat(ex, "{0}", ex.Message);
}
var slotData = slots.FirstOrDefault(x => x.GridData.Name == name);
if (slotData != null)
{
var slot = AutoMapper.Mapper.Map<SlotData, SlotModel>(slotData);
Protein protein = _proteinDictionary.GetProteinOrDownload(slotData.UnitInfo.ProjectID);
// build unit info logic
var unitInfoLogic = ServiceLocator.Resolve<UnitInfoLogic>();
unitInfoLogic.CurrentProtein = protein;
unitInfoLogic.UnitInfoData = slotData.UnitInfo;
slot.Prefs = _prefs;
slot.Settings = settings;
slot.UnitInfoLogic = unitInfoLogic;
return slot;
}
return new SlotModel { Prefs = _prefs, Settings = settings };
}
public IClient Create(ClientSettings settings)
{
if (settings == null) throw new ArgumentNullException("settings");
if (String.IsNullOrEmpty(settings.Name))
{
throw new ArgumentException("Failed to create client. No name given.");
}
if (settings.IsFahClient() && String.IsNullOrEmpty(settings.Server))
{
throw new ArgumentException("Failed to create client. No server given.");
}
if (settings.IsLegacy() && String.IsNullOrEmpty(settings.Path))
{
throw new ArgumentException("Failed to create client. No path given.");
}
string preCleanInstanceName = settings.Name;
ICollection<string> cleanupWarnings = CleanupSettings(settings);
if (!Validate.ClientName(settings.Name))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
"Failed to create client. Client name '{0}' is not valid after cleaning.", preCleanInstanceName));
}
if (cleanupWarnings.Count != 0)
{
_logger.Warn("------------------------");
_logger.Warn("Client Settings Warnings");
_logger.Warn("------------------------");
_logger.Warn("Client Name: {0}", settings.Name);
foreach (var error in cleanupWarnings)
{
_logger.Warn(error);
}
}
IClient client;
if (settings.IsFahClient())
{
client = ServiceLocator.Resolve<FahClient>();
}
else if (settings.IsLegacy())
{
client = ServiceLocator.Resolve<LegacyClient>();
}
else
{
// no External support yet
throw new InvalidOperationException("Client type is not supported.");
}
client.Settings = settings;
return client;
}
public void AddTest3()
{
// Arrange
var settings = new ClientSettings { Name = "test" };
_factory.Expect(x => x.Create(settings)).Return(
new FahClient(MockRepository.GenerateStub<IFahClientInterface>()));
// Act
_clientDictionary.Add(settings);
// Assert
_factory.VerifyAllExpectations();
}
private IClient CreateWrapper(ClientSettings settings)
{
try
{
return Create(settings);
}
catch (ArgumentException ex)
{
_logger.ErrorFormat(ex, "{0}", ex.Message);
return null;
}
}
/// <summary>
/// Execute Data Retrieve
/// </summary>
public void Execute(ClientSettings settings)
{
if (settings == null) throw new ArgumentNullException("settings");
Settings = settings;
switch (Settings.LegacyClientSubType)
{
case LegacyClientSubType.Path:
RetrievePathInstance();
break;
case LegacyClientSubType.Http:
RetrieveHttpInstance();
break;
case LegacyClientSubType.Ftp:
RetrieveFtpInstance();
break;
default:
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
"Instance Type '{0}' is not implemented", Settings.LegacyClientSubType));
}
}
public void CreateCollectionTest()
{
var builder = new ClientFactory();
var result1 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Path,
Name = "Client 1",
Path = @"\\test\path1\"
};
var result2 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Http,
Name = "Client 2",
Path = @"\\test\path2\"
};
var result3 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Ftp
};
var instances = builder.CreateCollection(new[] { result1, result2, result3 });
Assert.AreEqual(2, instances.Count());
}
public void CreateCollectionTest()
{
var legacyClientFactory = MockRepository.GenerateStub<ILegacyClientFactory>();
legacyClientFactory.Stub(x => x.Create()).Return(new LegacyClient());
var builder = new ClientFactory { LegacyClientFactory = legacyClientFactory };
var result1 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Path,
Name = "Client 1",
Path = @"\\test\path1\"
};
var result2 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Http,
Name = "Client 2",
Path = @"\\test\path2\"
};
var result3 = new ClientSettings(ClientType.Legacy)
{
LegacyClientSubType = LegacyClientSubType.Ftp
};
var instances = builder.CreateCollection(new[] { result1, result2, result3 });
Assert.AreEqual(2, instances.Count());
}
public void CreateTest()
{
var legacyClientFactory = MockRepository.GenerateStub<ILegacyClientFactory>();
legacyClientFactory.Stub(x => x.Create()).Return(new LegacyClient());
var builder = new ClientFactory { LegacyClientFactory = legacyClientFactory };
var settings = new ClientSettings(ClientType.Legacy)
{
Name = "Client{ 1",
Path = @"\\test\path\"
};
var instance = builder.Create(settings);
Assert.IsNotNull(instance);
Assert.AreEqual("Client 1", instance.Settings.Name);
}
public void Create_LegacyClientFactoryNull_Test()
{
var builder = new ClientFactory();
var settings = new ClientSettings(ClientType.Legacy)
{
Name = "LegacyClient",
Path = @"\\test\path\"
};
var instance = builder.Create(settings);
Assert.IsNull(instance);
}
public void Create_FahClientFactoryNull_Test()
{
var builder = new ClientFactory();
var settings = new ClientSettings(ClientType.FahClient)
{
Name = "FahClient",
Server = "192.168.100.200"
};
var instance = builder.Create(settings);
Assert.IsNull(instance);
}
private static ICollection<string> CleanupSettings(ClientSettings settings)
{
var warnings = new List<string>();
#region General Settings (common to FahClient and Legacy)
if (!Validate.ClientName(settings.Name))
{
// remove illegal characters
warnings.Add(String.Format(CultureInfo.InvariantCulture,
"Client Name '{0}' contained invalid characters and was cleaned.", settings.Name));
settings.Name = Validate.CleanClientName(settings.Name);
}
if (settings.ClientTimeOffset < Constants.MinOffsetMinutes ||
settings.ClientTimeOffset > Constants.MaxOffsetMinutes)
{
warnings.Add("Client time offset is out of range, defaulting to 0.");
settings.ClientTimeOffset = 0;
}
#endregion
if (settings.IsLegacy())
{
#region Legacy Settings
if (String.IsNullOrEmpty(settings.FahLogFileName))
{
warnings.Add("No remote FAHlog.txt filename, loading default.");
settings.FahLogFileName = Constants.FahLogFileName;
}
if (String.IsNullOrEmpty(settings.UnitInfoFileName))
{
warnings.Add("No remote unitinfo.txt filename, loading default.");
settings.UnitInfoFileName = Constants.UnitInfoFileName;
}
if (String.IsNullOrEmpty(settings.QueueFileName))
{
warnings.Add("No remote queue.dat filename, loading default.");
settings.QueueFileName = Constants.QueueFileName;
}
#endregion
}
else if (settings.IsFahClient())
{
if (!Validate.ServerPort(settings.Port))
{
warnings.Add("Server port is invalid, loading default.");
settings.Port = Constants.DefaultFahClientPort;
}
}
return warnings.AsReadOnly();
}
public void CreateTest()
{
var builder = new ClientFactory();
var settings = new ClientSettings(ClientType.Legacy)
{
Name = "Client{ 1",
Path = @"\\test\path\"
};
var instance = builder.Create(settings);
Assert.IsNotNull(instance);
Assert.AreEqual("Client 1", instance.Settings.Name);
}
