/// <summary>
/// Handles the Click event of the button1 control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void button1_Click(object sender, EventArgs e)
{
try
{
ReferenceScope scope = GetReferenceScope();
lstArtefacts.Items.Clear();
ConfigurationMode mode = new ConfigurationMode(cbMode.Text);
ReferenceWalker w = new ReferenceWalker(scope, mode);
string folder = null;
if ((string)cbAction.SelectedItem == "current solution")
{
folder = @"c:\[sln]\";
}
ReferenceVisitor rv = new ReferenceVisitor(scope, folder);
w.Traverse(rv, _system);
// ReferenceContext context = new ReferenceContext(mode, scope, (ReferenceContext.ReferenceSource)cbAction.SelectedItem, CandleModel.GetInstance(((ModelElement)system).Store), "project folder\\..\\");
foreach (string item in rv.References)
{
lstArtefacts.Items.Add(item);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private static object[] GetRowData(
TimeTillCompletionEstimationsCollection estimations,
int simulationIndex,
ConfigurationMode mode,
CultureInfo culture)
{
WorkEstimate roadmapEstimate = estimations.GetRoadmapEstimationForSimulation(simulationIndex);
var rowData = new object[]
{
FormatEstimatedNumberOfWorkingDays(roadmapEstimate, culture),
roadmapEstimate.IsIndeterminate
};
if (mode == ConfigurationMode.Advanced)
{
var additionalRowData = new object[estimations.NumberOfProjectsInRoadmap * 2];
for (int projectIndex = 0; projectIndex < estimations.NumberOfProjectsInRoadmap; projectIndex++)
{
WorkEstimate projectEstimate = estimations.GetProjectEstimationForSimulation(projectIndex, simulationIndex);
additionalRowData[projectIndex * 2] = FormatEstimatedNumberOfWorkingDays(projectEstimate, culture);
additionalRowData[projectIndex * 2 + 1] = projectEstimate.IsIndeterminate;
}
rowData = rowData.Concat(additionalRowData).ToArray();
}
return(rowData);
}
//Download To Device
private bool DownloadToDevice(DeviceExtended deviceextended, string selectedPcInterface)
{
DeviceSinamicsG sinamicsG = new DeviceSinamicsG(deviceextended);
DownloadProvider downloadProvider = deviceextended.device.DeviceItems[1].GetService <DownloadProvider>(); //TODO check
DownloadConfigurationDelegate pre = PreDownload;
DownloadConfigurationDelegate post = PostDownload;
ConnectionConfiguration connConfiguration = downloadProvider.Configuration;
ConfigurationMode configurationMode = connConfiguration.Modes.Find("PN/IE");
ConfigurationPcInterface pcInterface = configurationMode.PcInterfaces.Find(selectedPcInterface, 1);
ConfigurationSubnet subnet = pcInterface.Subnets.Find(sinamicsG.subnet.Name);
IConfiguration configuration = subnet.Addresses.Find(sinamicsG.ipAddress);
try
{
downloadProvider.Download(configuration, pre, post, DownloadOptions.Software);
}
catch (Exception ex)
{
return(false);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReferenceContext"/> struct.
/// </summary>
/// <param name="mode">The mode.</param>
/// <param name="scope">The scope.</param>
/// <param name="ports">The ports.</param>
/// <param name="isExternal">if set to <c>true</c> [is external].</param>
public ReferenceContext(ConfigurationMode mode, ReferenceScope scope, List <Guid> ports, bool isExternal)
{
Mode = mode;
Scope = scope;
Ports = ports;
IsExternal = isExternal;
}
/// <summary>
/// Shows Configuration Dialog
/// </summary>
/// <param name="mode">Configuration mode for settings dialog</param>
/// <param name="project">Project to manage configuration for</param>
/// <returns>Returns result of a configuration dialog</returns>
public async Task <DialogResult> ShowConfigurationDialogAsync(ConfigurationMode mode)
{
var settings = await SettingsService.Instance.GetSettingsAsync();
var project = await projectHelper.GetSelectedProjectAsync();
var crmConnections = settings.CrmConnections == null ? new CrmConnections()
{
Connections = new List <ConnectionDetail>()
} : settings.CrmConnections;
var selector = new ConnectionSelector(crmConnections, settings.SelectedConnection, false, mode == ConfigurationMode.Update);
selector.OnCreateMappingFile = () => {
mappingHelper.CreateMappingFile(project);
MessageBox.Show("UploaderMapping.config successfully created", "Microsoft Dynamics CRM Web Resources Updater", MessageBoxButtons.OK, MessageBoxIcon.Information);
};
selector.ShowDialog();
settings.CrmConnections = selector.ConnectionList;
if (selector.DialogResult == DialogResult.OK || selector.DialogResult == DialogResult.Yes)
{
settings.SelectedConnection = selector.SelectedConnection;
}
settings.Save();
return(selector.DialogResult);
}
/// <summary>
/// Checks the references.
/// </summary>
/// <param name="loadModelIfNotPresents">if set to <c>true</c> [load model if not presents].</param>
/// <param name="context">The context.</param>
/// <param name="mode">The mode.</param>
/// <param name="scope">The scope.</param>
/// <param name="element">The element.</param>
internal static void CheckReferences(bool loadModelIfNotPresents, ValidationContext context,
ConfigurationMode mode, ReferenceScope scope, ModelElement element)
{
CheckReferenceVisitor visitor = new CheckReferenceVisitor(loadModelIfNotPresents, scope, context);
ReferenceWalker walker = new ReferenceWalker(scope, mode);
walker.Traverse(visitor, element);
}
/// <summary>
/// Gets the references.
/// </summary>
/// <param name="mode">The mode.</param>
/// <param name="scope">The scope.</param>
/// <param name="solutionFolder">The solution folder.</param>
/// <param name="element">The element.</param>
/// <returns></returns>
public static ReferencesCollection GetReferences(ConfigurationMode mode, ReferenceScope scope,
string solutionFolder, ModelElement element)
{
ReferenceVisitor visitor = new ReferenceVisitor(scope, solutionFolder);
ReferenceWalker walker = new ReferenceWalker(scope, mode);
walker.Traverse(visitor, element);
return(visitor.References);
}
public static string ModeToXml(ConfigurationMode mode)
{
var xml = new StringBuilder();
xml.AppendFormat("<Mode name=\"{0}\">", mode.Name).AppendLine();
foreach (var map in mode.Mappings)
xml.AppendFormat(" <Map trigger=\"{0}\" action=\"{1}\" />", map.Key, map.Value).AppendLine();
xml.AppendLine("</Mode>");
return xml.ToString();
}
/// <summary>
/// Génération du fichier de config à partir des fichiers de l'utilisateur
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="project">The project.</param>
/// <param name="projectFolder">The project folder.</param>
/// <param name="forceGeneration">if set to <c>true</c> [force generation].</param>
/// <returns></returns>
private string GenerateConfigurationFile(Layer layer, Project project, string projectFolder,
bool forceGeneration)
{
if (project == null)
{
return(null);
}
IShellHelper shell = ServiceLocator.Instance.GetService <IShellHelper>();
// Vérification si le répertoire de config existe
string configFolderPath = Path.Combine(projectFolder, ConfigFolderName);
// On s'assure de son intègration dans la solution
Directory.CreateDirectory(configFolderPath);
ProjectItem folder = shell.AddFolderToProject(project.ProjectItems, ConfigFolderName);
// Création des fichiers à personnaliser
// D'abord le fichier correspondant au mode courant.
ConfigurationMode mode = new ConfigurationMode(project);
string currentFileName = CreateCustomConfigurationFile(mode.CurrentMode, configFolderPath, folder);
// Puis le fichier commun
string commonFileName = CreateCustomConfigurationFile("Common", configFolderPath, folder);
if (forceGeneration || File.GetLastWriteTime(commonFileName) > _lastGenerationTime ||
File.GetLastWriteTime(currentFileName) > _lastGenerationTime)
{
// Fichier généré
string generatedFileName = CalculateApplicationConfigurationFileName(layer);
if (generatedFileName == null)
{
return(configFolderPath);
}
if (project != null && shell != null)
{
// Création d'un fichier xml correspondant à la fusion du fichier commun et
// du fichier correspondant au contexte courant (debug, release...)
// Merge
XmlMerger merger = new XmlMerger();
XmlDocument customDocument = merger.MergeXml(currentFileName, commonFileName);
// Puis merge avec les config du modèle
XmlDocument resultDocument = MergeDeclaredConfigurations(customDocument, layer.Component);
// Sauvegarde
string generatedFilePath = Path.Combine(projectFolder, generatedFileName);
Directory.CreateDirectory(Path.GetDirectoryName(generatedFilePath));
shell.EnsureCheckout(generatedFilePath);
resultDocument.Save(generatedFilePath);
shell.AddFileToProject(project, generatedFilePath);
}
}
return(configFolderPath);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReferenceWalker"/> class.
/// </summary>
/// <param name="scope">The scope.</param>
/// <param name="configuration">The configuration.</param>
public ReferenceWalker(ReferenceScope scope, ConfigurationMode configuration)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
_scope = scope;
_configuration = configuration;
}
/// <returns>True if the configuration mode was successfully changed. False otherwise.</returns>
public bool SwitchToAdvancedConfigurationMode()
{
if (Mode == ConfigurationMode.Advanced)
{
return(false);
}
Mode = ConfigurationMode.Advanced;
return(true);
}
/// <summary>
/// Traverses the specified layer.
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="Scope">The scope.</param>
/// <param name="mode">The mode.</param>
public void Traverse(SoftwareLayer layer, ReferenceScope Scope, ConfigurationMode mode)
{
// Stocke les éléments traités pour éviter les doublons
List <Guid> guids = new List <Guid>();
if (layer is InterfaceLayer)
{
foreach (ServiceContract contract in ((InterfaceLayer)layer).ServiceContracts)
{
foreach (Implementation impl in Implementation.GetLinksToImplementations(contract))
{
if (mode.CheckConfigurationMode(impl.ConfigurationMode) &&
!guids.Contains(impl.ClassImplementation.Id))
{
_visitor.Accept(impl, impl.ClassImplementation);
guids.Add(impl.ClassImplementation.Id);
}
}
}
}
else if (layer is Layer)
{
foreach (ClassImplementation clazz in ((Layer)layer).Classes)
{
foreach (NamedElement service in clazz.ServicesUsed)
{
IList <ClassUsesOperations> externalServiceLinks =
ClassUsesOperations.GetLinksToServicesUsed(clazz);
foreach (ClassUsesOperations link in externalServiceLinks)
{
if (mode.CheckConfigurationMode(link.ConfigurationMode) && ((link.Scope & Scope) == Scope))
{
if (service is ExternalServiceContract)
{
_visitor.Accept(link, (ExternalServiceContract)service);
}
else if (service is ServiceContract)
{
_visitor.Accept(link, (ServiceContract)service);
}
else if (service is ClassImplementation)
{
_visitor.Accept(link, (ClassImplementation)service);
}
else
{
throw new Exception("Type not implemented");
}
guids.Add(service.Id);
}
}
}
}
}
}
/// <summary>
/// Copie les executables et les artefacts dans le répertoire d'exécution
/// </summary>
/// <param name="model">The model.</param>
public static void CopyToRuntimeFolder(CandleModel model)
{
if (model.Component == null)
{
return;
}
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
string targetFolder = string.Empty;
try
{
// Recherche du projet de démarrage pour savoir dans quel répertoire copier les artifacts
object[] files = (object[])ServiceLocator.Instance.ShellHelper.Solution.SolutionBuild.StartupProjects;
if (files == null || files.Length == 0)
{
return; // Pas trouvé
}
string startupProjectName = (string)files[0];
startupProjectName = Path.GetFileNameWithoutExtension(startupProjectName);
EnvDTE.Project startupProject = ServiceLocator.Instance.ShellHelper.FindProjectByName(startupProjectName);
if (startupProject == null)
{
// Recherche diffèrente pour un projet web
startupProjectName = Path.GetFileName(startupProjectName);
startupProject = ServiceLocator.Instance.ShellHelper.FindProjectByName(startupProjectName);
if (startupProject == null)
{
if (logger != null)
{
logger.Write("Copy binary to runtime folder error", "Unable to find the startup project " + startupProjectName, LogType.Warning);
}
return;
}
}
// Vérification des dépendances
ReferencesHelper.CheckReferences(false, null, new ConfigurationMode(), ReferenceScope.Runtime, model);
ConfigurationMode mode = new ConfigurationMode(startupProject);
// Répertoire destination
targetFolder = Path.Combine(Path.GetDirectoryName(startupProject.FullName), mode.BinPath);
CopyInFolder(targetFolder, model, mode);
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Copy to runtime folder", String.Format("erreur when copying runtime artifacts to {0}", targetFolder), ex);
}
}
}
public static void Init(ConfigurationMode activeMode, ConfigurationInfoList infoList)
{
Configuration.activeMode = activeMode;
foreach (KeyValuePair<ConfigurationMode, ConfigurationInfo> keyValuePair in (Dictionary<ConfigurationMode, ConfigurationInfo>) infoList)
Configuration.infoList.Add(keyValuePair.Key, keyValuePair.Value);
ProviderManager.Added += (args) =>
{
foreach (ConfigurationInfo configurationInfo in Configuration.infoList.Values)
configurationInfo.Refresh();
};
// new ProviderEventHandler(Configuration.ProviderManager_Added);
}
// static Configuration()
// {
// }
public static void Init(ConfigurationMode activeMode, ConfigurationInfoList infoList)
{
Configuration.activeMode = activeMode;
foreach (KeyValuePair<ConfigurationMode, ConfigurationInfo> pair in infoList)
Configuration.infoList.Add(pair.Key, pair.Value);
ProviderManager.Added += (args) =>
{
foreach (ConfigurationInfo configurationInfo in Configuration.infoList.Values)
configurationInfo.Refresh();
};
}
public static char ModeToChar(ConfigurationMode mode)
{
switch (mode)
{
case ConfigurationMode.Simulation:
case ConfigurationMode.Paper:
return ConfigurationModeConverter.MODE_SIMULATION;
case ConfigurationMode.Live:
return ConfigurationModeConverter.MODE_LIVE;
default:
throw new ArgumentException("Unknown configuration mode");
}
}
/// <exception cref="System.ArgumentException">Thrown when <paramref name="workEstimates"/> doesn't contain at least 1 simulation.</exception>
public void Write(TimeTillCompletionEstimationsCollection workEstimates, ConfigurationMode configurationMode)
{
if (workEstimates.Count == 0)
{
throw new ArgumentException("Work estimations should have at least 1 simulation.", nameof(workEstimates));
}
DataView dataView = factory.FromTimeTillCompletionEstimations(
workEstimates,
configurationMode,
CultureInfo.InvariantCulture);
WriteHeader(dataView.Table.Columns);
WriteRows(dataView);
}
public static char ModeToChar(ConfigurationMode mode)
{
switch (mode)
{
case ConfigurationMode.Simulation:
case ConfigurationMode.Paper:
return(ConfigurationModeConverter.MODE_SIMULATION);
case ConfigurationMode.Live:
return(ConfigurationModeConverter.MODE_LIVE);
default:
throw new ArgumentException("Unknown configuration mode");
}
}
// static Configuration()
// {
// }
public static void Init(ConfigurationMode activeMode, ConfigurationInfoList infoList)
{
Configuration.activeMode = activeMode;
foreach (KeyValuePair <ConfigurationMode, ConfigurationInfo> pair in infoList)
{
Configuration.infoList.Add(pair.Key, pair.Value);
}
ProviderManager.Added += (args) =>
{
foreach (ConfigurationInfo configurationInfo in Configuration.infoList.Values)
{
configurationInfo.Refresh();
}
};
}
public static void Init(ConfigurationMode activeMode, ConfigurationInfoList infoList)
{
Configuration.activeMode = activeMode;
foreach (KeyValuePair <ConfigurationMode, ConfigurationInfo> keyValuePair in (Dictionary <ConfigurationMode, ConfigurationInfo>)infoList)
{
Configuration.infoList.Add(keyValuePair.Key, keyValuePair.Value);
}
ProviderManager.Added += (args) =>
{
foreach (ConfigurationInfo configurationInfo in Configuration.infoList.Values)
{
configurationInfo.Refresh();
}
};
// new ProviderEventHandler(Configuration.ProviderManager_Added);
}
public static ConfigurationMode ModeFromXml(XmlNode xml)
{
var name = xml.Attributes.GetNamedItem("name").Value;
var mode = new ConfigurationMode(name);
foreach (XmlNode map in xml.SelectNodes("Map"))
{
var trigger = map.Attributes.GetNamedItem("trigger").Value;
var action = map.Attributes.GetNamedItem("action").Value;
if (mode.Mappings.ContainsKey(trigger))
continue; // must be bad config
mode.Mappings.Add(trigger, action);
}
return mode;
}
public async Task <Configuration> GetConfigurationAsync(ConfigurationMode mode)
{
// Creating default settings in case failure to retrieve
Configuration config = new Configuration()
{
KioskDisplayRecycleCount = 3,
GeneralRotationDelay = 0.15,
PriorityRotationDelay = 5,
MinFontSize = 10,
MaxFontSize = 20,
KioskEntryTopMargin = 200,
GrowAnimationDuration = 3,
ShrinkAnimationDuration = 3,
FallAnimationDurationTimeModifier = 25,
ScreenBottomMargin = 600
};
using (var client = new HttpClient())
{
var startTime = DateTime.Now;
//var path = $"/api/configuration?configurationmode" + Convert.ToInt32(mode); //TODO: Magic string
var path = $"/api/configuration"; //TODO: Magic string
var fullPath = WebServerUrl + path;
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = await client.GetAsync(fullPath);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsStringAsync();
config = JsonConvert.DeserializeObject <Configuration>(result); //TODO: Refactor
}
else
{
//TODO: Log response error
Console.WriteLine($"Failed to retrieve configuration settings from server. Using default settings.");
//Log.Error("Error downloading from person repository");
//Log.Error("Error: {0}", response.StatusCode);
}
//Console.WriteLine($"Downloaded {list.Count}");
//var totalTime = DateTime.Now.Subtract(startTime);
//Console.WriteLine($"Total download time {totalTime}");
}
return(config);
}
/// <returns>True if the configuration mode was successfully changed. False otherwise.</returns>
public bool SwitchToSimpleConfigurationMode()
{
if (Mode == ConfigurationMode.Simple)
{
return(false);
}
if (configuration.Projects.Count > 1 &&
!confirmationAsker.ConfirmToProceed("Switching to 'Simple Mode' will cause all projects to be flattened into one. Do you want to continue?"))
{
return(false);
}
FlattenProjectsIntoOne();
Mode = ConfigurationMode.Simple;
return(true);
}
/// <exception cref="ArgumentNullException">Thrown when any argument is null.</exception>
public DataView FromTimeTillCompletionEstimations(
TimeTillCompletionEstimationsCollection estimations,
ConfigurationMode mode,
CultureInfo culture)
{
if (estimations is null)
{
throw new ArgumentNullException(nameof(estimations));
}
Debug.Assert(estimations.RoadmapEstimations.Count > 0,
$"Invariant failed: Should guarantee at least 1 work estimation.");
string identifier = estimations.RoadmapEstimations.First().Identifier;
var dataTable = new DataTable();
AddReadOnlyColumn($"Number of days till completion of '{identifier}' in simulation", dataTable);
AddReadOnlyColumn($"Is '{identifier}' estimation indeterminate", dataTable);
if (mode == ConfigurationMode.Advanced)
{
for (int i = 0; i < estimations.NumberOfProjectsInRoadmap; i++)
{
IReadOnlyCollection <WorkEstimate> projectEstimations = estimations[i];
Debug.Assert(projectEstimations.Count > 0,
$"Invariant failed: Should guarantee at least 1 work estimation for project.");
identifier = projectEstimations.First().Identifier;
AddReadOnlyColumn($"Number of days till completion of '{identifier}' in simulation", dataTable);
AddReadOnlyColumn($"Is '{identifier}' estimation indeterminate", dataTable);
}
}
for (int i = 0; i < estimations.NumberOfSimulations; i++)
{
object[] rowData = GetRowData(estimations, i, mode, culture);
dataTable.Rows.Add(rowData);
}
return(dataTable.DefaultView);
}
/// <summary>
/// Shows Configuration Dialog
/// </summary>
/// <param name="mode">Configuration mode for settings dialog</param>
/// <param name="project">Project to manage configuration for</param>
/// <returns>Returns result of a configuration dialog</returns>
public static DialogResult ShowConfigurationDialog(ConfigurationMode mode, Project project)
{
var settings = ProjectHelper.GetSettings();
var crmConnections = settings.CrmConnections ?? new CrmConnections {
Connections = new List <ConnectionDetail>()
};
var manager = new ConnectionManager
{
ConnectionsList = crmConnections
};
var selector = new ConnectionSelector(crmConnections, manager, settings.SelectedConnection, false, mode == ConfigurationMode.Update)
{
WorkingProject = project
};
selector.ShowDialog();
settings.CrmConnections = selector.ConnectionList;
if (selector.DialogResult == DialogResult.OK || selector.DialogResult == DialogResult.Yes)
{
settings.SelectedConnection = selector.SelectedConnection;
}
settings.Save();
return(selector.DialogResult);
}
public static ConfigurationInfo GetConfiguration(ConfigurationMode mode)
{
return Configuration.infoList[mode];
}
/// <summary>
/// Copie des fichiers référencés dans un répertoire
/// </summary>
/// <param name="targetFolder">Répertoire destination</param>
/// <param name="model">The model.</param>
/// <param name="mode">The mode.</param>
internal static void CopyInFolder(string targetFolder, CandleModel model, ConfigurationMode mode)
{
if (targetFolder == null)
{
throw new ArgumentNullException("targetFolder");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
if (mode == null)
{
throw new ArgumentNullException("mode");
}
if (!Directory.Exists(targetFolder))
{
return;
}
// Recherche des artifacts à copier
ReferencesCollection references = DSLFactory.Candle.SystemModel.Dependencies.ReferencesHelper.GetReferences(mode, ReferenceScope.Runtime, ServiceLocator.Instance.ShellHelper.SolutionFolder, model);
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
foreach (string fileName in references)
{
string target = Path.Combine(targetFolder, Path.GetFileName(fileName));
// string source = Path.Combine( sourceFolder, fileName );
try
{
if (!Utils.StringCompareEquals(target, fileName) && File.GetLastWriteTime(fileName) > File.GetLastWriteTime(target))
{
Utils.CopyFile(fileName, target);
Utils.UnsetReadOnly(target);
if (logger != null)
{
logger.Write("Copy local", String.Format("Runtime references : Copy file {0} to {1}", fileName, target), LogType.Info);
}
// Il y a peut-être un pdb
string pdbFileName = Path.ChangeExtension(fileName, ".pdb");
string pdbTargetName = Path.ChangeExtension(target, ".pdb");
Utils.CopyFile(pdbFileName, pdbTargetName);
Utils.UnsetReadOnly(pdbTargetName);
// Et un xml
string xmlFileName = Path.ChangeExtension(fileName, ".xml");
string xmlTargetName = Path.ChangeExtension(target, ".xml");
Utils.CopyFile(xmlFileName, xmlTargetName);
Utils.UnsetReadOnly(xmlTargetName);
}
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("Copy local", String.Format("Runtime references : Error when copying file {0} to {1}", fileName, target), ex);
}
}
}
}
public ConfigurationModeChangingEventArgs(ConfigurationMode activeMode, ConfigurationMode newMode) : base(false)
{
this.ActiveMode = activeMode;
this.NewMode = newMode;
}
public void Export(string filePath, TimeTillCompletionEstimationsCollection workEstimates, ConfigurationMode configurationMode)
{
try
{
using var writer = new StreamWriter(filePath);
var csvWriter = new WorkEstimationsCsvWriter(writer);
csvWriter.Write(workEstimates, configurationMode);
}
catch (Exception ex)
{
throw new FileExportException(
$"Failed to export work estimation to file '{filePath}', due to an unexpected error.",
ex);
}
}
void Start()
{
configurationMode = ConfigurationMode.SET;
commitButtonObject.GetComponent <CommitButtonController>().setText(setButtonText);
}
public static ConfigurationInfo GetConfiguration(ConfigurationMode mode)
{
return(Configuration.infoList[mode]);
}
public void showConfigurePanel(Data data, ConfigurationMode _configurationMode)
{
groundConfigurationPanel.SetActive(false);
lightConfigurationPanel.SetActive(false);
logSmokeDensityConfigurationPanel.SetActive(false);
barrierConfigurationPanel.SetActive(false);
windConfigurationPanel.SetActive(false);
smokeConfigurationPanel.SetActive(false);
dataType = data.dataType;
switch (dataType)
{
case Data.type.GROUND: {
groundConfigurationPanel.SetActive(true);
groundConfigurationPanel.GetComponent <GroundConfigurationPanelController>().init((GroundData)data);
break;
}
case Data.type.LIGHT: {
lightConfigurationPanel.SetActive(true);
lightConfigurationPanel.GetComponent <LightConfigurationPanelController>().init((LightData)data);
break;
}
case Data.type.LOGDENSITY: {
logSmokeDensityConfigurationPanel.SetActive(true);
logSmokeDensityConfigurationPanel.GetComponent <LogDensityConfigurationPanelController>().init((LogSmokeDensityData)data);
break;
}
case Data.type.BARRIER: {
barrierConfigurationPanel.SetActive(true);
barrierConfigurationPanel.GetComponent <BarrierConfigurationPanelController>().init((BarrierData)data);
break;
}
case Data.type.WIND: {
windConfigurationPanel.SetActive(true);
windConfigurationPanel.GetComponent <WindConfigurationPanelController>().init((WindData)data);
break;
}
case Data.type.SMOKE: {
smokeConfigurationPanel.SetActive(true);
smokeConfigurationPanel.GetComponent <SmokeConfigurationPanelController>().init((SmokeData)data);
break;
}
default: {
break;
}
}
configurationMode = _configurationMode;
switch (configurationMode)
{
case ConfigurationMode.ADD:
commitButtonObject.GetComponent <CommitButtonController>().setText(addButtonText);
break;
case ConfigurationMode.SET:
commitButtonObject.GetComponent <CommitButtonController>().setText(setButtonText);
break;
default:
break;
}
}
/// <summary>
/// Tells Specky to invoke the method once all strapping is complete.
/// </summary>
/// <param name="configurationMode">The configuration mode used to determine if the method should be invoked.</param>
/// <param name="configurationName">The configuration name used to determine if the method should be invoked. Used in conjunction with ConfigurationMode</param>
public SpeckyStrappedAttribute(ConfigurationMode configurationMode, string configurationName = "")
{
ConfigurationName = configurationName;
ConfigurationMode = configurationMode;
}
public ConfigurationModeChangingEventArgs(ConfigurationMode activeMode, ConfigurationMode newMode) : base(false)
{
this.ActiveMode = activeMode;
this.NewMode = newMode;
}
/// <summary> /// Converts the <paramref name="sourceValue" /> parameter to the <paramref name="destinationType" /> parameter using <paramref /// name="formatProvider" /> and <paramref name="ignoreCase" /> /// </summary> /// <param name="sourceValue">the <see cref="System.Object"/> to convert from</param> /// <param name="destinationType">the <see cref="System.Type" /> to convert to</param> /// <param name="formatProvider">not used by this TypeConverter.</param> /// <param name="ignoreCase">when set to <c>true</c>, will ignore the case when converting.</param> /// <returns> /// an instance of <see cref="ConfigurationMode" />, or <c>null</c> if there is no suitable conversion. /// </returns> public override object ConvertFrom(object sourceValue, global::System.Type destinationType, global::System.IFormatProvider formatProvider, bool ignoreCase) => ConfigurationMode.CreateFrom(sourceValue);
