public override bool CanAssist(RichCommandLineContext context)
{
Providers.Clear();
Providers.AddRange(standardProviders);
CommandLineArgument targetArgument = null;
if (context.PreviousNonWhitespaceToken != null && ArgParser.IsDashSpecifiedArgumentIdentifier(context.PreviousNonWhitespaceToken.Value))
{
var candidate = context.PreviousNonWhitespaceToken.Value.Substring(1);
targetArgument = (from a in Definition.AllGlobalAndActionArguments where a.IsMatch(candidate) select a).SingleOrDefault();
}
if (targetArgument != null)
{
foreach (var assistant in targetArgument.Metadata.Metas <ArgContextualAssistant>())
{
var dynamicProvider = assistant.GetContextAssistProvider(Definition);
Providers.Add(dynamicProvider);
}
}
foreach (var provider in Providers)
{
if (provider is PowerArgsContextAwareAssistant)
{
(provider as PowerArgsContextAwareAssistant).TargetArgument = targetArgument;
}
}
var ret = base.CanAssist(context);
return(ret);
}
public Settings() : base()
{
provider = new CustomSettingsProvider();
Providers.Clear();
Providers.Add(provider);
}
private async void Start()
{
var x = PressButton;
MessageResult = "";
if (PressButton == PROVEEDOR)
{
var list = await providerService.GetProviderName(SearchName);
Providers.Clear();
HasCoincidence = (list.Count > 0) ? true : false;
foreach (var item in list)
{
Providers.Add(new Provider()
{
Code = item.Code,
Name = item.Name
});
}
}
else
{
var _list = new List <OrderTShirt>();
_list.Add(new OrderTShirt()
{
Code = SearchName
});
SearchOrder(_list);
}
}
public void OnAppearing()
{
Providers.Clear();
foreach (Provider provider in Provider.SelectAll())
{
Providers.Add(provider);
}
}
public void Clear()
{
ProgTypes.Clear();
Providers.Clear();
SectorSubjectAreaTier1s.Clear();
SectorSubjectAreaTier2s.Clear();
Standards.Clear();
StandardSectorCodes.Clear();
}
public static void ClearMetadata()
{
lock (internalMetadataProviders) {
internalMetadataProviders.Clear();
}
UpdateLocators();
Providers.Clear();
FilteringProviders.Clear();
}
public async Task PopulateAuthProvidersFromDB()
{
Providers.Clear();
IEnumerable <AuthProvider> providers = null;
providers = await DataAccessLayer.Current.GetAuthProvidersAsync();
Providers.AddRange(providers);
}
/// <summary>
/// Resets the provider collection. This needs to be called when providers change after
/// first being set.
/// </summary>
private void ResetProviders()
{
Providers.Clear();
foreach (SettingsProperty sp in Properties)
{
if (Providers[sp.Provider.Name] == null)
{
Providers.Add(sp.Provider);
}
}
}
/// <summary>
/// Load the satellite collection from the tuning files.
/// </summary>
/// <param name="directoryName">The full path of the directory containing the tuning files.</param>
public static void Load(string directoryName)
{
Providers.Clear();
DirectoryInfo directoryInfo = new DirectoryInfo(directoryName);
foreach (FileInfo fileInfo in directoryInfo.GetFiles("*.xml"))
{
ISDBSatelliteProvider satellite = new ISDBSatelliteProvider(fileInfo.Name.Substring(0, fileInfo.Name.Length - 4));
satellite.load(fileInfo);
AddProvider(satellite);
}
}
/// <summary>
/// Load the terrestrial collection from the tuning files.
/// </summary>
/// <param name="directoryName">The full path of the directory containing the tuning files.</param>
public static void Load(string directoryName)
{
Providers.Clear();
DirectoryInfo directoryInfo = new DirectoryInfo(directoryName);
foreach (FileInfo fileInfo in directoryInfo.GetFiles("*.xml"))
{
TerrestrialProvider terrestrialProvider = new TerrestrialProvider(fileInfo.Name.Substring(0, fileInfo.Name.Length - 4));
terrestrialProvider.load(fileInfo);
AddProvider(terrestrialProvider);
}
}
private async Task LoadProviderLookupAsync()
{
Providers.Clear();
Providers.Add(new NullLookupItem {
DisplayMember = " - "
});
var lookup = await _providerLookupDataService.GetProviderLookupAsync();
foreach (var lookupItem in lookup)
{
Providers.Add(lookupItem);
}
}
public void Clear()
{
Apprenticeships.Clear();
Courses.Clear();
Frameworks.Clear();
ProgTypes.Clear();
Providers.Clear();
SectorSubjectAreaTier1s.Clear();
SectorSubjectAreaTier2s.Clear();
Standards.Clear();
StandardSectorCodes.Clear();
Venues.Clear();
}
private void OnProvidersListLoaded(object sender, EventArgs args)
{
//**************************************************************************************************
// When provider list loading is completed.
//*************************************************************************************************
Providers.Clear();
var providersList = ServiceManager.Instance.ProviderService.GetProviderListFullInfo();
providersList.Sort((a, b) => a.Label.CompareTo(b.Label));
var selectedprovider = ServiceManager.Instance.ConfigurationService.Get(Configuration.ConfSection.GENERAL, Configuration.ConfEntry.CURRENT_PROVIDER, "");
var provider = ServiceManager.Instance.ProviderService.FindProviderLooseSearch(selectedprovider);
VATRPServiceProvider emptyProvider = new VATRPServiceProvider();
emptyProvider.Label = "None";
Providers.Add(new ProviderViewModel(emptyProvider));
foreach (var s in providersList)
{
if (s.Address == "_nologo" || s.Label == "_nologo")
{
continue; //If provider logo is not available then continue with next provider.
}
if (s.Address == null)
{
continue; //If the provider doesn't have an address, then we can't use it for dial-around
}
var providerModel = new ProviderViewModel(s);
Providers.Add(providerModel);
if (provider == null && s.Address == App.CurrentAccount.ProxyHostname)
{
selectedprovider = s.Label;
provider = s;
}
if (s.Label == selectedprovider)
{
SelectedProvider = providerModel;
}
}
if (_selectedProvider == null)
{
if (Providers != null && Providers.Count > 0)
{
_selectedProvider = Providers[0];
}
}
SelectedProviderIndex = 0;
}
private void InitializeProviders(LAPP.IO.MediaFile File)
{
Providers.Clear();
Providers.Add(new Providers.VolumeEx());
if (Config.Current.bValue[Enums.bValue.Spectrum])
{
//Providers.SampleAggregator sa = new Providers.SampleAggregator();
//sa.SetFFT(new Providers.SampleAggregator.FFTInfo() { Enable = false, Length = 256 });
//spectrum.SampleAggreator = sa;
//Providers.Add(sa);
}
}
//Формирует список провайдеров для отображения
protected void MakeProviders()
{
if (ApplicationType != ApplicationType.Controller)
{
return;
}
Providers.Clear();
foreach (var p in ProvidersDic.Values)
{
if (p.Type.ToProviderType() != ProviderType.Imitator || ImitMode != ImitMode.NoImit)
{
Providers.Add(p);
}
}
}
public void OnAppearing()
{
Customers.Clear();
Items.Clear();
Providers.Clear();
foreach (Customer customer in Customer.SelectAll())
{
Customers.Add(customer);
}
foreach (Item item in Item.SelectAll())
{
Items.Add(item);
}
foreach (Provider provider in Provider.SelectAll())
{
Providers.Add(provider);
}
}
public async Task LoadAsync()
{
var lookup = await _customerLookupService.GetCustomerLookupAsync();
Customers.Clear();
foreach (var item in lookup)
{
Customers.Add(new NavigationItemViewModel(item.Id, item.DisplayMember,
nameof(CustomerDetailViewModel),
_eventAggregator));
}
lookup = await _providerLookupService.GetProviderLookupAsync();
Providers.Clear();
foreach (var item in lookup)
{
Providers.Add(new NavigationItemViewModel(item.Id, item.DisplayMember,
nameof(ProviderDetailViewModel),
_eventAggregator));
}
lookup = await _productLookupService.GetProductLookupAsync();
Products.Clear();
foreach (var item in lookup)
{
Products.Add(new NavigationItemViewModel(item.Id, item.DisplayMember,
nameof(ProductDetailViewModel),
_eventAggregator));
}
lookup = await _orderLookupService.GetOrderLookupAsync();
Orders.Clear();
foreach (var item in lookup)
{
Orders.Add(new NavigationItemViewModel(item.Id, item.DisplayMember,
nameof(OrderDetailViewModel),
_eventAggregator));
}
}
public void Load()
{
try
{
Providers.Clear();
// find provider files:
foreach (var textFile in FileSystem.Directory.GetFiles(ConfigDir, ConfigFileName, SearchOption.TopDirectoryOnly))
{
var provider = LoadProvider(textFile);
Providers.Add(provider.Name, provider);
}
}
catch (FileNotFoundException)
{
}
catch (DirectoryNotFoundException)
{
}
}
/// <summary>
/// 加载Provider
/// </summary>
protected void GetProviders(XmlNode node)
{
foreach (XmlNode provider in node.ChildNodes)
{
switch (provider.Name)
{
case "add":
Providers.Add(provider.Attributes["name"].Value, new Provider(provider.Attributes));
break;
case "remove":
Providers.Remove(provider.Attributes["name"].Value);
break;
case "clear":
Providers.Clear( );
break;
}
}
}
//Загрузка списка провайдеров
public void ReadProviders()
{
try
{
Providers.Clear();
using (var rec = new ReaderAdo(File, "SELECT * FROM Providers WHERE (ProviderType <> '" + "Коммуникатор" + "')"))
{
while (rec.Read())
{
var p = new Provider(rec, ThreadCalc);
try { p.Codes = General.ProviderConfigs[p.Code].JointProviders; }
catch (Exception ex) { AddError("Не установлен провайдер", ex, p.Code); }
if (!ThreadCalc.ProvidersDic.ContainsKey(p.Name))
{
Providers.Add(p.Name, p);
ThreadCalc.ProvidersDic.Add(p.Name, p);
p.Projects.Add(Code);
if (p.Code == "HandInputSource" || p.Code == "HandInputSqlSource")
{
HandInputProvider = p;
}
AddEvent("Загружен провайдер");
}
else
{
var pr = ThreadCalc.ProvidersDic[p.Name];
Providers.Add(p.Name, pr);
pr.Projects.Add(Code);
}
}
}
}
catch (Exception ex)
{
ThreadCalc.AddError("Ошибка чтения списка провайдеров из проекта", ex, "Проект=" + Code);
}
}
public static void Refresh()
{
Providers.Clear();
try
{
using (SqlConnection sqlConnection = DBUtil.CreateConnection(ConnectionSource.Communication))
{
using (SqlCommand cmd = new SqlCommand(SelectCommandText, sqlConnection))
{
cmd.Connection.Open();
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
MailProvider provider = new MailProvider();
provider.Id = reader.GetInt32(0);
provider.Name = reader.GetString(1);
provider.Url = reader.GetString(2);
provider.Description = reader.GetString(3);
provider.PackageSize = reader.GetInt32(4);
provider.StandbyPeriod = reader.GetInt32(5);
Providers.Add(provider.Id, provider);
}
cmd.Connection.Close();
}
}
}
catch (Exception ex)
{
providers = null;
throw ex;
}
}
private void UpdateProviders(int counter = 0)
{
if (counter == 3)
{
ClientContext.Logger.LogWarning($"Failed to reach API! ({counter} retries!)");
return;
}
try {
ApiClient.CreateRequest("api/ressources", "GET").Execute(out HttpWebResponse response);
if (response.TryGetStatusCode(out HttpStatusCode code))
{
string responseString = response.GetReponseString();
if (response.StatusCode == HttpStatusCode.OK)
{
RessourcesProviderView ressourcesProviderView = responseString.DeserializeJsonSafe <RessourcesProviderView>();
if (ressourcesProviderView != null)
{
lock (Providers) {
Providers.Clear();
Providers.AddRange(ressourcesProviderView.Providers);
}
ClientContext.Logger.LogSuccess($"Providers updated successfully! (Count: {ressourcesProviderView.Providers.Count})");
return;
}
ClientContext.Logger.LogWarning($"Failed to extract deserialize response ['{responseString}']");
}
else
{
ClientContext.Logger.LogWarning($"Montitor request failed [Code: {response.StatusCode.ToString("G")}, Response: '{responseString}']");
}
}
} catch (Exception e) {
ClientContext.Logger.LogError(e);
}
UpdateProviders(++counter);
}
public void GetProviders(XmlNode _node)
{
foreach (XmlNode _providerNode in _node.ChildNodes)
{
switch (_providerNode.Name)
{
case "add":
Providers.Add(_providerNode.Attributes["name"].Value, new ProviderBase(_providerNode.Attributes));
break;
case "remove":
Providers.Remove(_providerNode.Attributes["name"].Value);
break;
case "clear":
Providers.Clear();
break;
default:
break;
}
}
}
public Settings() //: base()
{
Providers.Clear();
PropertyChanged += Settings_PropertyChanged;
}
/// <summary>
/// Writes the class diagram.
/// </summary>
/// <param name="class">The class.</param>
/// <param name="useIncludes">if set to <c>true</c> [use includes].</param>
/// <returns></returns>
internal static string WriteClassDiagram(Models.Class @class, bool useIncludes = false)
{
string markup = Templates.Descriptor;
if (@class.Module)
{
markup = markup.Replace(ProtoTypeElement, "").Replace(StereoTypeElement, string.Format(StereoType, "M", "application", "module "));
}
else if (@class.Static && @class.Abstract)
{
markup = markup.Replace(ProtoTypeElement, "").Replace(StereoTypeElement, string.Format(StereoType, "S", "orchid", "static "));
}
else if (@class.Abstract)
{
markup = markup.Replace(ProtoTypeElement, "abstract ").Replace(StereoTypeElement, "");
}
else
{
markup = markup.Replace(ProtoTypeElement, "").Replace(StereoTypeElement, "");
}
markup = markup.Replace(TypeElement, "class ").Replace(NameElement, @class.Name);
markup = markup.Replace(BodyElement, WriteBody(@class));
if (@class.Implements != null)
{
markup += Lollipop(@class.Name, @class.Implements.Name);
}
if (@class.Inherits != null)
{
markup += Extend(@class.Name, @class.Inherits.Name);
}
var aggregates = Aggregations.Distinct().ToList();
Aggregations.Clear();
var composites = Compositions.Distinct().ToList();
Compositions.Clear();
var consumption = Consumers.Distinct().ToList();
Consumers.Clear();
var provision = Providers.Distinct().ToList();
Providers.Clear();
aggregates.ForEach((n) =>
{
if (useIncludes)
{
markup = ((IncludeDiagram(n).Length > 0) ? IncludeDiagram(n) : "") + markup;
}
markup += Aggregate(@class.Name, n);
Relationships.Add(new Models.Relationship
{
PrincipalObject = @class,
AncillaryObject = new Models.Generic {
Name = n
},
Type = Models.RelationshipType.Aggregation
});
});
composites.ForEach((n) =>
{
if (useIncludes)
{
markup = ((IncludeDiagram(n).Length > 0) ? IncludeDiagram(n) : "") + markup;
}
markup += Composite(@class.Name, n);
Relationships.Add(new Models.Relationship
{
PrincipalObject = @class,
AncillaryObject = new Models.Generic {
Name = n
},
Type = Models.RelationshipType.Composition
});
});
consumption.ForEach((n) =>
{
if (useIncludes)
{
markup = ((IncludeDiagram(n).Length > 0) ? IncludeDiagram(n) : "") + markup;
}
markup += Consumes(@class.Name, n);
Relationships.Add(new Models.Relationship
{
PrincipalObject = @class,
AncillaryObject = new Models.Generic {
Name = n
},
Type = Models.RelationshipType.Dependency
});
});
Providers.ForEach((n) =>
{
if (useIncludes)
{
markup = ((IncludeDiagram(n).Length > 0) ? IncludeDiagram(n) : "") + markup;
}
markup += Provides(@class.Name, n);
Relationships.Add(new Models.Relationship
{
PrincipalObject = @class,
AncillaryObject = new Models.Generic {
Name = n
},
Type = Models.RelationshipType.Association
});
});
return(markup);
}
public MyUserSettings()
: base()
{
Providers.Clear();
Providers.Add(new CustomProvider());
}
