protected override void ProcessRecord()
{
var qb = new QuerystringBuilder();
if (Ids != null && Ids.Any())
{
qb.Add("ids", Ids);
}
if (Names != null && Names.Any())
{
qb.Add("names", Names);
}
if (ClusterPartitionIds != null && ClusterPartitionIds.Any())
{
qb.Add("clusterPartitionIds", ClusterPartitionIds);
}
if (FetchStats.IsPresent)
{
qb.Add("fetchStats", true.ToString());
}
var preparedUrl = $"/public/viewBoxes{qb.Build()}";
var result = Session.ApiClient.Get <IEnumerable <ViewBox> >(preparedUrl);
WriteObject(result, true);
}
/// <summary>
/// Process Records
/// </summary>
protected override void ProcessRecord()
{
var qb = new QuerystringBuilder();
if (Names != null && Names.Any())
{
qb.Add("usernames", string.Join(",", Names));
}
if (EmailAddresses != null && EmailAddresses.Any())
{
qb.Add("emailAddresses", string.Join(",", EmailAddresses));
}
if (!string.IsNullOrWhiteSpace(Domain))
{
qb.Add("domain", Domain);
}
var preparedUrl = $"/public/users{qb.Build()}";
WriteDebug(preparedUrl);
var result = Session.ApiClient.Get <IEnumerable <Models.User> >(preparedUrl);
WriteObject(result, true);
}
protected override void ProcessRecord()
{
var queries = new Dictionary <string, string>();
// Always include last run and stats
queries.Add("includeLastRunAndStats", true.ToString().ToLower());
if (OnlyActive.IsPresent)
{
queries.Add("isActive", true.ToString().ToLower());
}
if (OnlyInactive.IsPresent)
{
queries.Add("isActive", false.ToString().ToLower());
}
if (OnlyDeleted.IsPresent)
{
queries.Add("isDeleted", true.ToString().ToLower());
}
if (Ids != null && Ids.Any())
{
queries.Add("ids", string.Join(",", Ids));
}
if (Names != null && Names.Any())
{
queries.Add("names", string.Join(",", Names));
}
if (PolicyIds != null && PolicyIds.Any())
{
queries.Add("policyIds", string.Join(",", PolicyIds));
}
if (Environments != null && Environments.Any())
{
List <string> envs = Environments.ToList().ConvertAll <string>(x => x.ToString().First().ToString().ToLower() + x.ToString().Substring(1));
queries.Add("environments", string.Join(",", envs));
}
var queryString = string.Empty;
if (queries.Any())
{
queryString = "?" + string.Join("&", queries.Select(q => $"{q.Key}={q.Value}"));
}
var preparedUrl = $"/public/protectionJobs{queryString}";
var results = Session.ApiClient.Get <IEnumerable <Model.ProtectionJob> >(preparedUrl);
// Hide deleted protection jobs unless explicitly asked for
if (!OnlyDeleted.IsPresent)
{
results = results.Where(x => !(x.Name.StartsWith("_DELETED"))).ToList();
}
WriteObject(results, true);
}
public bool Any(Name x)
{
return
(Names.Any(
y => object.ReferenceEquals(x, y) ||
y.LastName == x.LastName && y.FirstName == x.FirstName));
}
public bool RecoveryNameSettingIfNeed()
{
bool needPopupNotification = false;
while (Names.Count < 2)
{
var masters = CodeMasterServce.GetMasters <JobMaster>();
var target1 = CodeMasterServce.GetNameRandom();
while (Names.Any(item => target1.Attribute == item.Attribute))
{
target1 = CodeMasterServce.GetNameRandom();
}
var target2 = masters[MyRandom.GetRandom(masters.Count)];
var gotName = new Name(target1, target2);
Names.Add(gotName);
needPopupNotification = true;
}
if (Names.Count >= 1 && (MainName == null || !Names.Contains(MainName)))
{
while ((SubName != null && SubName.Equals(MainName)) || (MainName == null || !Names.Contains(MainName)))
{
MainName = Names[MyRandom.GetRandom(Names.Count)];
}
needPopupNotification = true;
}
if (Names.Count >= 2 && (SubName == null || !Names.Contains(SubName)))
{
while ((SubName != null && SubName.Equals(MainName)) || (SubName == null || !Names.Contains(SubName)))
{
SubName = Names[MyRandom.GetRandom(Names.Count)];
}
needPopupNotification = true;
}
return(needPopupNotification);
}
public IQueryable <Account> Filter(IQueryable <Account> filterQuery)
{
if (!string.IsNullOrEmpty(SearchTerm))
{
if (Guid.TryParse(SearchTerm, out var accId))
{
filterQuery = filterQuery.Where(t => t.Id == accId);
}
else
{
filterQuery = filterQuery.Where(t => t.Email == SearchTerm);
}
}
if (Ids.Count > 0)
{
filterQuery = filterQuery.Where(t => Ids.Any(v => v == t.Id));
}
if (Names.Count > 0)
{
filterQuery = filterQuery.Where(t => Names.Any(v => t.Name.Contains(v)));
}
return(filterQuery);
}
/// <summary>
/// Indicates whether the name must be selected for advice.
/// </summary>
/// <param name="reflectionName">Name of the reflection.</param>
/// <returns></returns>
public bool Select(string reflectionName)
{
if (Names.Count == 0)
{
return(true);
}
return(Names.Any(n => MatchName(n, reflectionName)));
}
public SettingPath(IEnumerable <string> names)
{
Names = (names ?? throw new ArgumentNullException(nameof(names))).ToList();
if (!Names.Any())
{
throw new ArgumentException(nameof(names), "Names must not be empty.");
}
}
public void addName(string n)
{
if (!Names.Any(x => x.name == n))
{
Names.Add(new NameEntry {
name = n, unk = 0, flags = 0x00070010
});
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SiteCommandHandler"/> class.
/// </summary>
/// <param name="connectionAccessor">The accessor to get the connection that is active during the <see cref="Process"/> method execution.</param>
/// <param name="extensions">All registered extensions.</param>
public SiteCommandHandler(
IFtpConnectionAccessor connectionAccessor,
[NotNull, ItemNotNull] IEnumerable <IFtpCommandHandlerExtension> extensions)
: base(connectionAccessor, "SITE")
{
Extensions = extensions
.Where(x => Names.Any(name => string.Equals(name, x.ExtensionFor, StringComparison.OrdinalIgnoreCase)))
.SelectMany(x => x.Names.Select(n => new { Name = n, Extension = x }))
.ToDictionary(x => x.Name, x => x.Extension, StringComparer.OrdinalIgnoreCase);
}
private T GetDefaultName()
{
if (!Names.Any())
{
return(null);
}
var name = FirstName(sortNames.DefaultLanguage);
return(name ?? Names.First());
}
// Handles customizations for NPCs
// Custom NPCs and custom names or sprites for existing NPCs
private void LoadCustomNpcs()
{
foreach (var npc in ModMain.GetVillagers())
{
GetNpcCrop(npc);
GetCustomName(npc);
}
// For farmhands, custom NPCs can't be found so rely on config
if (Context.IsMultiplayer && !Context.IsMainPlayer)
{
var CustomNpcMarkerOffsets = ModMain.Globals.CustomNpcMarkerOffsets;
if (CustomNpcMarkerOffsets != null && CustomNpcMarkerOffsets.Count > 0)
{
foreach (var villager in CustomNpcMarkerOffsets)
{
NpcMarkerOffsets[villager.Key] = villager.Value;
}
}
}
// Handle duplicate displayName -- custom NPCs that replaces villagers
Dictionary <string, string> dupes = Names
.Where(n1 => Names.Any(n2 => n2.Key != n1.Key && n2.Value == n1.Value))
.ToDictionary(n => n.Key, n => n.Value);
// Properly replace the villager with custom NPC
foreach (var dupe in dupes)
{
if (dupe.Key != dupe.Value)
{
Names[dupe.Key] = dupe.Value;
}
else
{
Names.Remove(dupe.Key);
}
}
if (NpcCustomizations.Count != 0)
{
var names = "Adjusted markers for ";
foreach (var name in NpcCustomizations)
{
names += name + ", ";
}
ModMain.IMonitor.Log(names.Substring(0, names.Length - 2), LogLevel.Debug);
}
ModMain.Helper.Data.WriteJsonFile($"config/{Constants.SaveFolderName}.json", ModMain.Config);
}
/// <summary>
/// Process Record
/// </summary>
protected override void ProcessRecord()
{
var qb = new QuerystringBuilder();
if (ParentSourceId != null)
{
qb.Add("vCenterId", ParentSourceId.Value);
}
if (Names != null && Names.Any())
{
qb.Add("names", string.Join(",", Names));
}
if (Uuids != null && Uuids.Any())
{
qb.Add("uuids", string.Join(",", Uuids));
}
if (Unprotected.IsPresent && Protected.IsPresent)
{
throw new Exception("The parameters 'Unprotected' and 'Protected' can not be specified together");
}
if (Unprotected.IsPresent)
{
// Get a list of all the vms
var url = $"/public/protectionSources/virtualMachines{ qb.Build()}";
var vms = Session.ApiClient.Get <IEnumerable <Models.ProtectionSource> >(url);
// Get a list of protected vms
qb.Add("protected", true);
url = $"/public/protectionSources/virtualMachines{ qb.Build()}";
var protectedVms = Session.ApiClient.Get <IEnumerable <Models.ProtectionSource> >(url);
// Return the vms that are not in the list of protected vms
var result = vms.Where(x => !protectedVms.Any(y => x.Id == y.Id));
WriteObject(result, true);
}
else
{
if (Protected.IsPresent)
{
qb.Add("protected", true);
}
var url = $"/public/protectionSources/virtualMachines{ qb.Build()}";
var result = Session.ApiClient.Get <IEnumerable <Models.ProtectionSource> >(url);
WriteObject(result, true);
}
}
public static IDisposable RegisterPropertyChangedHandler_Disposable([NotNull] this INotifyPropertyChanged obj, PropertyChangedEventHandler handler, [NotNull] params string[] Names)
{
void Handler(object s, PropertyChangedEventArgs e)
{
if (Names.Any(name => string.Equals(name, e.PropertyName)))
{
handler(s, e);
}
}
obj.PropertyChanged += Handler;
return(new LambdaDisposable(() => obj.PropertyChanged -= Handler));
}
public ArchiveResourceCollection(Stream stream, string name)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
_zipped = new ZipArchive(stream);
Name = name;
// When Name is empty, entry is folder, ignore
Names = _zipped.Entries.Where(s => !string.IsNullOrEmpty(s.Name)).Select(s => s.FullName);
IsEmpty = !Names.Any();
}
/// <summary>
/// Initializes a new instance of the <see cref="ConceptViewModel"/> class.
/// </summary>
/// <param name="concept">The concept.</param>
public ConceptViewModel(Concept concept) : this()
{
this.Class = concept.Class?.Name;
this.ConceptSetId = Guid.Empty;
this.ConceptSets = concept.ConceptSets.Select(c => new ConceptSetViewModel(c)).ToList();
this.CreationTime = concept.CreationTime.DateTime;
this.Id = concept.Key.Value;
this.IsObsolete = concept.ObsoletionTime != null;
this.IsSystemConcept = concept.IsSystemConcept;
this.Languages = concept.ConceptNames.Select(k => new Language(k.Language, k.Name)).ToList();
this.Mnemonic = concept.Mnemonic;
this.Names = concept.ConceptNames.Select(c => c.Name).ToList();
this.ConceptNames = (Names.Any()) ? string.Join(", ", Names) : string.Empty;
this.ReferenceTerms = new List <ReferenceTermViewModel>();
this.VersionKey = concept.VersionKey;
}
//_____________________________________________________________________________________________________________________________________________________________
public string GenerateUniqueName(string proposedName)
{
proposedName = proposedName.RemoveInvalidChars();
if (!Names.Any(s => s.iEquals(proposedName)))
{
return(proposedName);
}
int i = 1;
string newName = $"{proposedName}_{i}";
while (Names.Any(s => s.iEquals(newName)))
{
newName = $"{proposedName}_{++i}";
}
return(newName);
}
public LocalFileResourceReader(string directory, int maxSearchLevel = MaxSearchLevel)
{
if (string.IsNullOrEmpty(directory))
{
_directory = Directory.GetCurrentDirectory();
}
else
{
_directory = directory;
}
Name = _directory;
_maxDepth = maxSearchLevel;
var includedFiles = GetFiles(_directory, "*", maxSearchLevel);
Names = includedFiles.Select(s => PathUtility.MakeRelativePath(_directory, s)).Where(s => s != null);
IsEmpty = !Names.Any();
}
public virtual void UpdateSortNames()
{
if (!Names.Any())
{
return;
}
var languages = new[] { ContentLanguageSelection.Japanese, ContentLanguageSelection.Romaji, ContentLanguageSelection.English };
foreach (var l in languages)
{
SetValueFor(l);
}
var additionalNames = Names.Select(n => n.Value).Where(n => !SortNames.All.Contains(n)).Distinct();
AdditionalNamesString = string.Join(", ", additionalNames);
}
public override string ToString()
{
var sb = new StringBuilder().AppendLine(MainName);
if (Names?.Any() == true)
{
sb.AppendLine(string.Join(", ", Names));
}
sb.AppendLine($"Лойсы: {Loisy}")
.AppendLine($"Зашкворы: {Zashkvory}")
.AppendLine($"Сливы: {Slivi}")
.AppendLine($"Может голосовать: {CanVote}");
foreach (var attribute in Attributes)
{
sb.AppendLine($"{attribute.AttributeName}: {attribute.Value}");
}
return(sb.ToString());
}
public void SetName(IEnumerable <BigInteger> prior, string firstName, string lastName)
{
var priorNames = Names.Where(n => prior.Contains(n.HashCodeInt));
if (priorNames.Count() == 1 && NameEquals(priorNames.Single(), firstName, lastName))
{
return;
}
var newName = new MathematicianName(priorNames, firstName, lastName);
if (Names.Any(n => n.HashCodeInt == newName.HashCodeInt))
{
return;
}
Names.Add(newName);
}
private void SetValueFor(ContentLanguageSelection language)
{
if (!Names.Any())
{
return;
}
var name = GetFirstName(language);
if (name != null)
{
SortNames[language] = name.Value;
}
if (string.IsNullOrEmpty(SortNames[language]))
{
SortNames[language] = Names.First().Value;
}
}
public IQueryable <House> Filter(IQueryable <House> filterQuery)
{
if (!string.IsNullOrEmpty(SearchTerm))
{
filterQuery = Guid.TryParse(SearchTerm, out var houseId)
? filterQuery.Where(t => t.Id == houseId)
: filterQuery.Where(t => CheckContains(t));
}
if (Ids.Count > 0)
{
filterQuery = filterQuery.Where(t => Ids.Any(v => v == t.Id));
}
if (Names.Count > 0)
{
filterQuery = filterQuery.Where(t => Names.Any(v => t.OwnerName.Contains(v)));
}
return(filterQuery);
}
// Handles customizations for NPCs
// Custom NPCs and custom names or sprites for existing NPCs
private void LoadCustomNpcs()
{
foreach (var npc in ModMain.GetVillagers())
{
GetNpcCrop(npc);
GetCustomName(npc);
}
// Handle duplicate displayName -- custom NPCs that replaces villagers
Dictionary <string, string> dupes = Names
.Where(n1 => Names.Any(n2 => n2.Key != n1.Key && n2.Value == n1.Value))
.ToDictionary(n => n.Key, n => n.Value);
// Properly replace the villager with custom NPC
foreach (var dupe in dupes)
{
if (dupe.Key != dupe.Value)
{
Names[dupe.Key] = dupe.Value;
}
else
{
Names.Remove(dupe.Key);
}
}
if (NpcCustomizations.Count != 0)
{
var names = "Adjusted markers for ";
foreach (var name in NpcCustomizations)
{
names += name + ", ";
}
ModMain.IMonitor.Log(names.Substring(0, names.Length - 2), LogLevel.Debug);
}
ModMain.Helper.Data.WriteJsonFile($"config/{Constants.SaveFolderName}.json", ModMain.Config);
}
private T GetFirstName(ContentLanguageSelection languageSelection)
{
if (!Names.Any())
{
return(null);
}
var name = FirstName(languageSelection);
// Substitute English with Romaji
if (name == null && languageSelection == ContentLanguageSelection.English)
{
name = FirstName(ContentLanguageSelection.Romaji);
}
// Substitute Romaji with English
if (name == null && languageSelection == ContentLanguageSelection.Romaji)
{
name = FirstName(ContentLanguageSelection.English);
}
return(name ?? GetDefaultName());
}
public virtual bool HasName(string val)
{
return(Names.Any(n => n.Value.Equals(val, StringComparison.InvariantCultureIgnoreCase)));
}
bool IDictionary <string, object> .ContainsKey(string key) => Names.Any(n => n.EqualsIgnoreCase(key));
public virtual bool HasName(LocalizedString name)
{
return(Names.Any(n => n.ContentEquals(name)));
}
public bool HasName(string name) => Names.Any(x => x.Equals(name, StringComparison.Ordinal));
public bool Includes(IPrincipal user)
{
return(Names.Any(user.IsInRole));
}