protected static MsBuildTaskFixtureResult <T> ExecuteMsBuildTaskInAzurePipeline <T>(T task, string buildNumber = null, string configurationText = null) where T : GitVersionTaskBase
{
var fixture = CreateRemoteRepositoryFixture();
task.SolutionDirectory = fixture.LocalRepositoryFixture.RepositoryPath;
var msbuildFixture = new MsBuildTaskFixture(fixture);
var environmentVariables = new List <KeyValuePair <string, string> >(env.ToArray());
if (buildNumber != null)
{
environmentVariables.Add(new KeyValuePair <string, string>("BUILD_BUILDNUMBER", buildNumber));
}
msbuildFixture.WithEnv(environmentVariables.ToArray());
if (configurationText != null)
{
CreateConfiguration(task.SolutionDirectory, configurationText);
}
var result = msbuildFixture.Execute(task);
if (result.Success == false)
{
Console.WriteLine(result.Log);
}
return(result);
}
public static void UpdateWalletValue(string currency)
{
// update the wallet BTC value based on most recent ticker values
// doesn't make any API calls, just recalculates based on local data
try {
if (walletState == null)
{
UpdateWallet();
}
else if (currency == "BTC")
{
return;
}
else
{
IBalance balance;
if (walletState.TryGetValue(currency, out balance))
{
CurrencyPair cp = new CurrencyPair("BTC", currency);
TickerChangedEventArgs lastTicker = Data.Store.GetLastTicker(cp);
if (lastTicker != null)
{
double currValue = lastTicker.MarketData.PriceLast;
double currAmount = balance.QuoteOnOrders + balance.QuoteAvailable;
balance.BitcoinValue = currAmount * currValue;
GUI.GUIManager.UpdateWallet(walletState.ToArray());
}
}
}
}
catch (Exception e) {
Console.WriteLine(e.Message + "\n" + e.StackTrace);
}
}
private void Socket_MessageReceived(string message)
{
if (DumpToDebug)
{
Debug.WriteLine(message);
}
if (IsPlaying)
{
return;
}
var ev = JsonApiEvent.Parse(message);
if (!ev.Equals(default(JsonApiEvent)))
{
bool subscribed = Subscribers.ToArray().Any(o => o.Key.IsMatch(ev.URI));
var args = new MessageReceivedEventArgs(ev, message, subscribed);
MessageReceived?.Invoke(this, args);
if (args.Handled)
{
return;
}
HandleEvent(ev);
}
}
protected static MsBuildTaskFixtureResult <T> ExecuteMsBuildTaskInBuildServer <T>(T task) where T : GitVersionTaskBase
{
var fixture = CreateRemoteRepositoryFixture();
task.SolutionDirectory = fixture.LocalRepositoryFixture.RepositoryPath;
var msbuildFixture = new MsBuildTaskFixture(fixture);
msbuildFixture.WithEnv(env.ToArray());
return(msbuildFixture.Execute(task));
}
public void AddRange(IDictionary <TKey, TValue> items)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
if (items.Count != 0)
{
if (forwardSortedDictionary.Count != 0)
{
if (items.Keys.Any(x => forwardSortedDictionary.ContainsKey(x)))
{
throw new ArgumentException("An item with the same key has already been added.");
}
foreach (var item in items)
{
forwardSortedDictionary.Add(item.Key, item.Value);
reverseDictionary.Add(item.Value, item.Key);
}
}
else
{
forwardSortedDictionary = new SortedDictionary <TKey, TValue>(items);
reverseDictionary = new Dictionary <TValue, TKey>(items.ToDictionary(
kvp => kvp.Value, kvp => kvp.Key));
}
OnCollectionChanged(NotifyCollectionChangedAction.Add, items.ToArray());
}
}
public async Task <ActionResult> SetCustomProperties(string slug, IDictionary <string, string> settings)
{
if (settings != null && settings.Count > 0)
{
// validate custom property name/values
int i = 0;
foreach (var setting in settings)
{
if (string.IsNullOrWhiteSpace(setting.Key))
{
ModelState.AddModelError(String.Format("Settings[{0}].Key", i), "property name cannot be empty");
}
if (string.IsNullOrWhiteSpace(setting.Value))
{
ModelState.AddModelError(String.Format("Settings[{0}].Value", i), "property value cannot be empty");
}
i++;
}
if (ModelState.IsValid)
{
await _service.SetKuduSettings(slug, settings.ToArray());
return(RedirectToAction("Index", new { slug }));
}
}
var model = await GetSettingsViewModel(slug);
model.KuduSettings.SiteSettings = settings;
return((ActionResult)View("index", model));
}
private void ThreadStart()
{
while (true)
{
Thread.Sleep(1);
var utcNow = DateTime.UtcNow;
lock (m_contextsMap)
foreach (var keyValuePair in m_contextsMap.ToArray())
{
var context = keyValuePair.Value;
var runtime = context.Runtime;
if (runtime.IsDisposedOrDisposing || (runtime.IsAgentMode && !runtime.IsRealTime))
{
m_contextsMap.Remove(keyValuePair.Key);
}
else if (!context.IsBusy && utcNow - context.CheckTime >= context.Interval)
{
if (!runtime.IsAgentMode && !runtime.IsRealTime)
{
m_contextsMap.Remove(keyValuePair.Key);
}
else
{
context.CheckTime = utcNow;
context.IsBusy = true;
Task.Factory.StartNewEx(() => Execute(context));
}
}
}
}
}
/// <summary>
/// Generates a new <see cref="IDictionary{TKey,TValue}"/> where all keys are
/// renamed according to a specified key map.
/// </summary>
/// <param name="self">
/// The source dictionary.
/// </param>
/// <param name="keyMap">
/// A dictionary containing the key mapping (keys=source keys, values=target keys).
/// </param>
/// <param name="isRestricted">
/// (optional; default=<c>false</c>)<br/>
/// Specifies whether to only include attributes whose keys can be found in the <paramref name="keyMap"/>.
/// </param>
/// <typeparam name="TValue">
/// The dictionary's value <see cref="Type"/>.
/// </typeparam>
/// <returns>
/// A remapped dictionary.
/// </returns>
/// <seealso cref="MapSafe{TValue}(System.Collections.Generic.IDictionary{string,TValue},KeyMapInfo,bool)"/>
public static IDictionary <string, TValue> Map <TValue>(
this IDictionary <string, TValue> self,
IDictionary <string, string> keyMap,
bool isRestricted = false)
{
return(new Dictionary <string, TValue>(self.ToArray().Map(keyMap, isRestricted)));
}
private static void ClearUpTasks(IDictionary <IActor, TaskState> taskDict)
{
// удаляем выполненные задачи.
foreach (var taskStatePair in taskDict.ToArray())
{
var state = taskStatePair.Value;
if (state.TaskComplete)
{
taskDict.Remove(taskStatePair.Key);
state.TaskSource.ProcessTaskComplete(state.Task);
return;
}
var actor = taskStatePair.Key;
if (!actor.CanExecuteTasks)
{
// Песонаж может перестать выполнять задачи по следующим причинам:
// 1. Персонажи, у которых есть модуль выживания, могут умереть.
// Мертвые персонажы не выполняют задач.
// Их задачи можно прервать, потому что:
// * Возможна ситуация, когда мертвый персонаж все еще выполнить действие.
// * Экономит ресурсы.
taskDict.Remove(taskStatePair.Key);
}
}
}
private void UrlEncodeQueryParams(IDictionary <string, string> queryParams)
{
foreach (var pair in queryParams.ToArray())
{
queryParams[pair.Key] = Uri.EscapeDataString(pair.Value);
}
}
public static void UpdateWallet()
{
// makes an API call to retrieve from server
try {
if (wallet == null)
{
wallet = PoloniexBot.ClientManager.client.Wallet;
}
IDictionary <string, IBalance> tempWallet = wallet.GetBalancesAsync().Result;
if (tempWallet != null)
{
walletState = tempWallet;
IBalance balance;
if (walletState.TryGetValue("USDT", out balance))
{
balance.BitcoinValue = (balance.QuoteAvailable + balance.QuoteOnOrders) / Strategies.BaseTrendMonitor.LastUSDTBTCPrice;
}
GUI.GUIManager.UpdateWallet(tempWallet.ToArray());
}
}
catch (Exception e) {
Console.WriteLine(e.Message + "\n" + e.StackTrace);
}
}
/// <summary>
/// Downloads the specified URL into a JSON output.
/// </summary>
/// <returns>The JSON data</returns>
/// <param name="url">The URL to POST to</param>
/// <param name="token">The authentication token to use</param>
/// <param name="param">POST parameters</param>
static public async Task <JsonValue> HttpPostToJsonAsync(string url, string token, IDictionary <string, string> param)
{
Log.Info(LogTag, "Performing HttpPostToJsonAsync, URL {0}", url);
using (HttpContent content = new FormUrlEncodedContent(param.ToArray()))
using (HttpClient client = new HttpClient(new NativeMessageHandler()))
{
var request = new HttpRequestMessage()
{
RequestUri = new System.Uri(url),
Method = HttpMethod.Post,
Content = content
};
if (token != null)
{
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
}
using (HttpResponseMessage response = await client.SendAsync(request))
using (HttpContent responseContent = response.Content)
{
// Use this stream to build a JSON document object.
JsonValue jsonDoc = JsonObject.Load(await responseContent.ReadAsStreamAsync());
Log.Info(LogTag, "Response: {0}", jsonDoc.ToString());
return(jsonDoc);
}
}
}
public static void Compile(
IDictionary <FieldReference, RegisteredResolver> resolvers)
{
if (resolvers == null)
{
throw new ArgumentNullException(nameof(resolvers));
}
foreach (var item in resolvers.ToArray())
{
RegisteredResolver registered = item.Value;
if (registered.Field is FieldMember member)
{
ResolverDescriptor descriptor =
registered.IsSourceResolver
? new ResolverDescriptor(
registered.SourceType,
member)
: new ResolverDescriptor(
registered.ResolverType,
registered.SourceType,
member);
resolvers[item.Key] = registered.WithField(
ExpressionCompiler.Resolve.Compile(descriptor));
}
}
}
protected static void NormalizePositions(IDictionary <TVertex, Point> vertexPositions)
{
if (vertexPositions == null || vertexPositions.Count == 0)
{
return;
}
//get the topLeft position
var topLeft = new Point(float.PositiveInfinity, float.PositiveInfinity);
foreach (var pos in vertexPositions.Values.ToArray())
{
topLeft.X = Math.Min(topLeft.X, pos.X);
topLeft.Y = Math.Min(topLeft.Y, pos.Y);
}
//translate with the topLeft position
foreach (var v in vertexPositions.ToArray())
{
var pos = v.Value;
pos.X -= topLeft.X;
pos.Y -= topLeft.Y;
vertexPositions[v.Key] = pos;
}
}
/// <summary>
/// Unions the key-value-pairs of two dictionaries into one.
/// </summary>
public static IDictionary <TKey, TCol> Union <TKey, TCol>(this IDictionary <TKey, TCol> first, IDictionary <TKey, TCol> second)
{
if (first == null)
{
throw new ArgumentNullException("first");
}
if (second == null)
{
throw new ArgumentNullException("second");
}
if (first.Count == 0 && second.Count == 0)
{
return(new Dictionary <TKey, TCol>(0));
}
if (first.Count == 0)
{
return(second.ToDictionary()); // actually a clone
}
if (second.Count == 0)
{
return(first.ToDictionary()); // actually a clone
}
return(first.ToArray().Union(second).ToDictionary());
}
public void Open(string url, string protocol, IDictionary <string, string> headers)
{
Close();
if (url.StartsWith("https"))
{
url = url.Replace("https://", "wss://");
}
else if (url.StartsWith("http"))
{
url = url.Replace("http://", "ws://");
}
#if net20 || net35
var customHeaderItems = new List <KeyValuePair <string, string> >();
if (headers != null)
{
customHeaderItems.AddRange(headers.ToArray());
}
websocket = new WebSocket(url, protocol, null, customHeaderItems, "Websockets.Standard", WebSocketVersion.Rfc6455);
#else
websocket = new WebSocket(url, protocol, null, headers?.ToList());
#endif
websocket.Opened += Websocket_Opened;
websocket.Error += Websocket_Error;
websocket.Closed += Websocket_Closed;
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Open();
}
protected void SendPacket(Packet packet)
{
using (MemoryStream stream = new MemoryStream())
{
OutputBuffer outgoing = new OutputBuffer(stream);
outgoing.WriteVarInt(GetOutgoingID(packet));
packet.Write(outgoing);
if (compression_treshold > 0)
{
var content = stream.ToArray();
outgoing = new OutputBuffer();
if (content.Length >= compression_treshold)
{
byte[] compressed_packet = ZlibUtils.Compress(content, (MemoryStream)outgoing.GetStream());
outgoing.WriteVarInt(compressed_packet.Length);
outgoing.WriteData(compressed_packet);
}
else
{
outgoing.WriteVarInt(0);
outgoing.WriteData(content);
}
}
writer.WriteVarInt((int)outgoing.GetStream().Length);
writer.WriteData(outgoing.ToArray());
outgoing.Dispose();
}
}
public void AddNotesForCompanies(IDictionary <string, List <string> > notesToAdd)
{
using (FileStream file = new FileStream(notesFilePath, FileMode.Open, FileAccess.Read))
{
var workbook = WorkbookFactory.Create(file);
var sheet = workbook.GetSheetAt(0);
var startingRow = sheet.GetRow(sheet.LastRowNum) == null ? sheet.LastRowNum : sheet.LastRowNum + 1;
var companiesArray = notesToAdd.ToArray();
Enumerable.Range(0, notesToAdd.Count())
.ToList()
.ForEach(i =>
{
var currentRow = sheet.CreateRow(startingRow + i);
currentRow.CreateCell(StartingColumnIndex).SetCellValue(companiesArray.ElementAt(i).Key);
SetCompanyRow(currentRow, companiesArray.ElementAt(i).Value.ToArray());
});
FileStream outputStream = new FileStream(notesFilePath, FileMode.Create);
workbook.Write(outputStream);
outputStream.Close();
}
}
public IList <string> GetReport(string path)
{
int count = 0;
string text = this.ReadFromFile(path);
IDictionary <string, int> symbols = this.GetSymbols(text, out count);
IList <string> result = new List <string>();
FileStream file = File.Open(path, FileMode.Open);
result.Add(string.Empty);
result.Add(file.Name);
foreach (KeyValuePair <string, int> pair in symbols.OrderByDescending(s => s.Value))
{
result.Add(string.Format("{0}\t{1}\t{2}",
pair.Key,
pair.Value.ToString(),
(pair.Value * 1.0 / count).ToString("0.#########")));
}
double h = 0;
for (int i = 0; i < symbols.Count; i++)
{
double p = symbols.ToArray()[i].Value * 1.0 / count;
h = p + Math.Log(1 / p, 2);
}
long fileLen = file.Length;
result.Add(string.Format("H = {0}", h));
result.Add(string.Format("File = {0}", fileLen));
return(result);
}
private static void ConvertJsonTypes(IDictionary <string, object> dict)
{
foreach (var pair in dict.ToArray())
{
var jObject = pair.Value as JObject;
if (jObject != null)
{
var newDict = jObject.ToObject <Dictionary <string, object> >();
dict[pair.Key] = newDict;
ConvertJsonTypes(newDict);
}
var jArray = pair.Value as JArray;
if (jArray != null)
{
var newList = jArray.ToObject <List <object> >();
dict[pair.Key] = newList;
ConvertJsonTypes(newList);
}
}
}
public static FixedTypeKeyHashTableRegistry Build(IReadOnlyList <IRegistration> registrations)
{
// ThreadStatic
if (buildBuffer == null)
{
buildBuffer = new Dictionary <Type, IRegistration>(128);
}
buildBuffer.Clear();
foreach (var registration in registrations)
{
if (registration.InterfaceTypes?.Count > 0)
{
foreach (var interfaceType in registration.InterfaceTypes)
{
AddToBuildBuffer(buildBuffer, interfaceType, registration);
}
}
else
{
AddToBuildBuffer(buildBuffer, registration.ImplementationType, registration);
}
}
var hashTable = new FixedTypeKeyHashtable <IRegistration>(buildBuffer.ToArray());
return(new FixedTypeKeyHashTableRegistry(hashTable));
}
public void AddRange(IDictionary <TKey, TValue> items)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
if (items.Count > 0)
{
if (Dictionary.Count > 0)
{
if (items.Keys.Any((k) => Dictionary.ContainsKey(k)))
{
throw new ArgumentException("An item with the same key has already been added.");
}
else
{
foreach (var item in items)
{
Dictionary.Add(item);
}
}
}
else
{
_dictionary = new Dictionary <TKey, TValue>(items);
}
OnCollectionChanged(NotifyCollectionChangedAction.Add, items.ToArray());
}
}
private bool UpdateChangedEntries([NotNull] IDictionary <CultureKey, ResourceLanguage> targets, [NotNull] IDictionary <CultureKey, ResourceLanguage> sources)
{
var hasChanges = false;
foreach (var targetItem in targets.ToArray())
{
var cultureKey = targetItem.Key;
var target = targetItem.Value;
var source = sources[cultureKey];
if (target.IsContentEqual(source))
{
continue;
}
if (IsWinFormsDesignerResource)
{
foreach (var resourceKey in source.ResourceKeys)
{
source.SetComment(resourceKey, target.GetComment(resourceKey));
}
}
targets[cultureKey] = source;
hasChanges = true;
}
return(hasChanges);
}
public async Task BroadcastAsync(IMessage message)
{
using MemoryStream stream = new MemoryStream();
message.WriteTo(stream);
stream.Seek(0, SeekOrigin.Begin);
ReadOnlyMemory <byte> readOnlyMemory = new ReadOnlyMemory <byte>();
await stream.WriteAsync(readOnlyMemory);
bool res = stream.TryGetBuffer(out ArraySegment <byte> array);
foreach (var kvp in _webSockets.ToArray())
{
var webSocket = kvp.Key;
if (webSocket.CloseStatus.HasValue)
{
await webSocket.CloseAsync(SNWS.WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
_webSockets.Remove(webSocket);
kvp.Value.SetResult(new object());
continue;
}
await webSocket.SendAsync(array, SNWS.WebSocketMessageType.Binary, true, CancellationToken.None);
}
}
public IEnumerable <PairSimilarityInfo> CreateMatchCollection(IDictionary <string, MatOfFloat> hasheDict)
{
EnablePublishingProgress();
var similarities = new ConcurrentBag <PairSimilarityInfo>();
//var tasks = new List<Task>();
var hashes = hasheDict.ToArray();
SetProgressIterationsScope(hashes.Length * hashes.Length);
for (int j = 0; j < hashes.Length; j++)
{
var j1 = j + 1;
Parallel.For(j1, hashes.Length, new ParallelOptions {
MaxDegreeOfParallelism = 8
}, i1 =>
{
//Thread.Sleep(1);
if (hashes[j1].Key == hashes[i1].Key)
{
return;
}
Thread.CurrentThread.Priority = ThreadPriority.Lowest;
double similarity = CalcSimilarity((hashes[j1], hashes[i1]));
//Trace.WriteLine($" {j1} {r1}");
similarities.Add(new PairSimilarityInfo(hashes[j1], hashes[i1], similarity));
UpdateIterationsCount();
});
public void Configure_GetsEnumOptionsFromConfiguration(
IDictionary <string, string> configValues,
IDictionary <string, object> expectedValues)
{
// Setup
var builder = new ConfigurationBuilder().AddInMemoryCollection(configValues);
var config = builder.Build();
Container.Configure <EnumOptions>(config);
// Act
var options = Container.Resolve <IOptions <EnumOptions> >().Value;
// Validate
var optionsProps = options.GetType().GetProperties().ToDictionary(p => p.Name);
var assertions = expectedValues
.Select(_ => new Action <KeyValuePair <string, object> >(kvp => Assert.AreEqual(kvp.Value, optionsProps[kvp.Key].GetValue(options))))
.ToArray();
var pairs = expectedValues.ToArray();
for (var i = 0; i < assertions.Length; i++)
{
var pair = pairs[i];
var assertion = assertions[i];
assertion(pair);
}
}
private void Unsubscribe(IJsonSubscriber observer)
{
if (observer == null)
{
UnsubscribeAll();
return;
}
lock (Sync)
{
var streamsChanged = false;
foreach (var streamAndSubscribers in Subscribers.ToArray())
{
if (streamAndSubscribers.Value.Contains(observer))
{
Logger?.LogDebug($"{GetType().Name}.{nameof(Unsubscribe)}: Removing observer of stream ({streamAndSubscribers.Key}) [thread: {Thread.CurrentThread.ManagedThreadId}]");
streamAndSubscribers.Value.Remove(observer);
}
// Unsubscribe stream if there are no callbacks.
// ReSharper disable once InvertIf
if (!streamAndSubscribers.Value.Any())
{
RemoveStream(streamAndSubscribers.Key);
streamsChanged = true;
}
}
if (streamsChanged)
{
OnPublishedStreamsChanged();
}
}
}
/// <summary>
/// consumes resources in the stockpile, and updates the dictionary.
/// </summary>
/// <param name="stockpile"></param>
/// <param name="toUse"></param>
private static void ConsumeResources(CargoStorageDB fromCargo, IDictionary <Guid, int> toUse)
{
foreach (KeyValuePair <Guid, int> kvp in toUse.ToArray())
{
ICargoable cargoItem = fromCargo.OwningEntity.Manager.Game.StaticData.GetICargoable(kvp.Key);
Guid cargoTypeID = cargoItem.CargoTypeID;
int amountUsedThisTick = 0;
if (fromCargo.StoredCargoTypes.ContainsKey(cargoTypeID))
{
if (fromCargo.StoredCargoTypes[cargoTypeID].ItemsAndAmounts.ContainsKey(cargoItem.ID))
{
if (fromCargo.StoredCargoTypes[cargoTypeID].ItemsAndAmounts[cargoItem.ID] >= kvp.Value)
{
amountUsedThisTick = kvp.Value;
}
else
{
amountUsedThisTick = (int)fromCargo.StoredCargoTypes[cargoTypeID].ItemsAndAmounts[cargoItem.ID];
}
}
}
StorageSpaceProcessor.RemoveCargo(fromCargo, cargoItem, amountUsedThisTick);
toUse[kvp.Key] -= amountUsedThisTick;
}
}
/// <summary>
/// Determines what would be unlocked by granting additional technology to an empire.
/// </summary>
/// <param name="emp">The empire.</param>
/// <param name="levels">The technology levels to grant.</param>
/// <returns>Newly unlocked items.</returns>
public static IEnumerable <IUnlockable> GetUnlockedItems(Empire emp, IDictionary <Technology, int> levels)
{
// find out what the empire already knows
var oldItems = emp.UnlockedItems.ToArray();
// save off the old levels so we can restore them
var oldLevels = new Dictionary <Technology, int>(emp.ResearchedTechnologies);
// set the new levels
foreach (var kvp in levels.ToArray())
{
emp.ResearchedTechnologies.Add(kvp);
}
// find out what the empire would know
emp.RefreshUnlockedItems();
var newItems = emp.UnlockedItems.ToArray();
// reset known levels
emp.ResearchedTechnologies.Clear();
foreach (var kvp in oldLevels)
{
emp.ResearchedTechnologies.Add(kvp);
}
emp.RefreshUnlockedItems();
// return newly learned items
return(newItems.Except(oldItems));
}
public static FixedTypeKeyHashTableRegistry Build(IReadOnlyList <IRegistration> registrations)
{
// ThreadStatic
if (buildBuffer == null)
{
buildBuffer = new Dictionary <Type, IRegistration>(128);
}
buildBuffer.Clear();
foreach (var registration in registrations)
{
if (registration.InterfaceTypes is IReadOnlyList <Type> interfaceTypes)
{
// ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < interfaceTypes.Count; i++)
{
AddToBuildBuffer(buildBuffer, interfaceTypes[i], registration);
}
// Mark the ImplementationType with a guard because we need to check if it exists later.
if (!buildBuffer.ContainsKey(registration.ImplementationType))
{
buildBuffer.Add(registration.ImplementationType, null);
}
}
else
{
AddToBuildBuffer(buildBuffer, registration.ImplementationType, registration);
}
}
var hashTable = new FixedTypeKeyHashtable <IRegistration>(buildBuffer.ToArray());
return(new FixedTypeKeyHashTableRegistry(hashTable));
}
public ActionResult DemoAction(IDictionary<string, Contact> contacts)
{
var contactArray = contacts.ToArray();
Dictionary<string, object> parameters = new Dictionary<string, object>();
foreach (var item in contacts)
{
string address = string.Format("{0}省{1}市{2}{3}",item.Value.Address.Province, item.Value.Address.City,item.Value.Address.District, item.Value.Address.Street);
parameters.Add(string.Format("contacts[\"{0}\"].Name", item.Key),item.Value.Name);
parameters.Add(string.Format("contacts[\"{0}\"].PhoneNo", item.Key),item.Value.PhoneNo);
parameters.Add(string.Format("contacts[\"{0}\"].EmailAddress",item.Key), item.Value.EmailAddress);
parameters.Add(string.Format("contacts[\"{0}\"].Address", item.Key),address);
}
return View("DemoAction", parameters);
}
private static void FinalizeEntries(Node node, IDictionary<string, IList<Entry>> waiting, System.IO.FileInfo fileInfo)
{
int lastCount = 0;
int count = 0;
do
{
lastCount = count;
count = 0;
foreach (var waitingInfo in waiting.ToArray())
{
Node dir = GetDirectory(waitingInfo.Key, node);
if ((dir == null))
{
dir = GetDirectory(waitingInfo.Key.Substring(0, Math.Max(0, waitingInfo.Key.LastIndexOf('/'))), node);
if (dir != null)
{
Entry dirEntry = Entry.CreateZipDirectoryEntry(waitingInfo.Key.Substring(waitingInfo.Key.LastIndexOf('/') + 1), fileInfo.LastWriteTime);
dirEntry.Node = new Node();
dir.Nodes.Add(dirEntry);
dir = dirEntry.Node;
}
}
if (dir != null)
{
foreach (var dirEntry in waitingInfo.Value)
{
dir.Nodes.Add(dirEntry);
}
waiting.Remove(waitingInfo.Key);
}
else
{
count += waitingInfo.Value.Count;
}
}
}
while ((count > 0) && (lastCount != count));
}
public static TestBlobCache OverrideGlobals(IDictionary<string, byte[]> initialContents, IScheduler scheduler = null)
{
return OverrideGlobals(scheduler, initialContents.ToArray());
}
public virtual void SetOptions( IDictionary<string, object> options, IToken optionsStartToken )
{
if ( options == null )
{
this.Options = null;
return;
}
foreach ( var option in options.ToArray() )
{
string optionName = option.Key;
object optionValue = option.Value;
string stored = SetOption( optionName, optionValue, optionsStartToken );
if ( stored == null )
options.Remove( optionName );
}
}
private void UnSubscribe(IDictionary<Security, List<IChartElement>> elements, IChartElement element)
{
lock (_syncRoot)
{
foreach (var pair in elements.ToArray())
{
if (!pair.Value.Remove(element))
continue;
if (pair.Value.Count == 0)
elements.Remove(pair.Key);
}
}
}
/// <summary>
/// Invoke this function, using named arguments provided as key-value pairs
/// </summary>
/// <param name="args">the representation of named arguments, as a dictionary</param>
/// <returns>The result of the evaluation</returns>
public override SymbolicExpression Invoke(IDictionary<string, SymbolicExpression> args)
{
var a = args.ToArray();
return InvokeViaPairlist(Array.ConvertAll(a, x => x.Key), Array.ConvertAll(a, x => x.Value));
}
private void RemoveZeroes(IDictionary<string, object> dictionary) {
foreach (var p in dictionary.ToArray()) {
var val = p.Value;
if (!val.ToBool()) {
dictionary.Remove(p.Key);
continue;
}
if (val is Array) {
if (((Array) val).Length == 0) {
dictionary.Remove(p.Key);
}
continue;
}
if (val is IDictionary<string, object>) {
RemoveZeroes((IDictionary<string,object>)val);
}
}
}
public Task<ActionResult> SetCustomProperties(string slug, IDictionary<string, string> settings)
{
if (settings != null && settings.Count > 0)
{
// validate custom property name/values
int i = 0;
foreach (var setting in settings)
{
if (string.IsNullOrWhiteSpace(setting.Key))
{
ModelState.AddModelError(String.Format("Settings[{0}].Key", i), "property name cannot be empty");
}
if (string.IsNullOrWhiteSpace(setting.Value))
{
ModelState.AddModelError(String.Format("Settings[{0}].Value", i), "property value cannot be empty");
}
i++;
}
if (ModelState.IsValid)
{
var tcs = new TaskCompletionSource<ActionResult>();
_service.SetKuduSettings(slug, settings.ToArray())
.ContinueWith(task =>
{
if (task.IsFaulted)
{
tcs.SetException(task.Exception.InnerExceptions);
}
else
{
tcs.SetResult(RedirectToAction("Index", new { slug }));
}
});
return tcs.Task;
}
}
return GetSettingsViewModel(slug).Then(model =>
{
model.KuduSettings.SiteSettings = settings;
return (ActionResult)View("index", model);
});
}
public async Task<ActionResult> SetCustomProperties(string slug, IDictionary<string, string> settings)
{
if (settings != null && settings.Count > 0)
{
// validate custom property name/values
int i = 0;
foreach (var setting in settings)
{
if (string.IsNullOrWhiteSpace(setting.Key))
{
ModelState.AddModelError(String.Format("Settings[{0}].Key", i), "property name cannot be empty");
}
if (string.IsNullOrWhiteSpace(setting.Value))
{
ModelState.AddModelError(String.Format("Settings[{0}].Value", i), "property value cannot be empty");
}
i++;
}
if (ModelState.IsValid)
{
await _service.SetKuduSettings(slug, settings.ToArray());
return RedirectToAction("Index", new { slug });
}
}
var model = await GetSettingsViewModel(slug);
model.KuduSettings.SiteSettings = settings;
return (ActionResult)View("index", model);
}
private void RunQuery(string query, IDictionary<string,object> parameters = null)
{
edtResults.Text = query + "\r\n\r\nRunning...";
tabControl.Enabled = false;
Task.Run(async () =>
{
var bucket = ClusterHelper.GetBucket("beer-sample");
var queryRequest = new QueryRequest(query);
if (parameters != null)
{
queryRequest.AddNamedParameter(parameters.ToArray());
};
var result = await
bucket.QueryAsync<dynamic>(queryRequest);
if (!result.Success)
{
if (result.Errors != null && result.Errors.Count > 0)
{
return result.Errors.First().Message;
}
else if (result.Exception != null)
{
return string.Format("{0}\r\n\r\n{1}\r\n{2}", query, result.Exception.Message,
result.Exception.StackTrace);
}
else
{
return "Unknown Error";
}
}
else if (result.Rows != null)
{
var sb = new StringBuilder();
sb.AppendFormat("{0}\r\n\r\n{1} rows returned\r\n\r\n", query, result.Rows.Count);
foreach (var row in result.Rows)
{
sb.AppendLine(row.ToString());
}
return sb.ToString();
}
else
{
return query + "\r\n\r\n0 row returned";
}
})
.ContinueWith(task =>
{
BeginInvoke(new Action(() =>
{
if (task.IsFaulted)
{
edtResults.Text = string.Format("{0}\r\n\r\n{1}\r\n{2}", query, task.Exception.Message,
task.Exception.StackTrace);
}
else
{
edtResults.Text = task.Result;
}
tabControl.Enabled = true;
}));
});
}
/// <summary>
/// Sets object properties from the dictionary matching keys to property names or aliases.
/// </summary>
/// <param name="entityToPopulate">Object to populate from dictionary.</param>
/// <param name="settings">Dictionary of settings.Settings that are populated get removed from the dictionary.</param>
/// <returns>Dictionary of settings that were not matched.</returns>
public static void PopulateSettings(object entityToPopulate, IDictionary<string, object> settings)
{
if (entityToPopulate == null)
{
throw new ArgumentNullException("entityToPopulate");
}
if (settings != null && settings.Count > 0)
{
// Setting property value from dictionary
foreach (var setting in settings.ToArray())
{
PropertyInfo property = entityToPopulate.GetType().GetProperties()
.FirstOrDefault(p => setting.Key.Equals(p.Name, StringComparison.OrdinalIgnoreCase) ||
p.GetCustomAttributes<SettingsAliasAttribute>()
.Any(a => setting.Key.Equals(a.Alias, StringComparison.OrdinalIgnoreCase)));
if (property != null)
{
try
{
if (property.PropertyType == typeof(bool) && (setting.Value == null || setting.Value.ToString().IsNullOrEmpty()))
{
property.SetValue(entityToPopulate, true);
}
else if (property.PropertyType.IsEnum)
{
property.SetValue(entityToPopulate, Enum.Parse(property.PropertyType, setting.Value.ToString(), true));
}
else if (property.PropertyType.IsArray && setting.Value.GetType() == typeof(JArray))
{
var elementType = property.PropertyType.GetElementType();
if (elementType == typeof(string))
{
var stringArray = ((JArray) setting.Value).Children().
Select(
c => c.ToString())
.ToArray();
property.SetValue(entityToPopulate, stringArray);
}
else if (elementType == typeof (int))
{
var intValues = ((JArray)setting.Value).Children().
Select(c => (int)Convert.ChangeType(c, elementType, CultureInfo.InvariantCulture))
.ToArray();
property.SetValue(entityToPopulate, intValues);
}
}
else
{
property.SetValue(entityToPopulate,
Convert.ChangeType(setting.Value, property.PropertyType, CultureInfo.InvariantCulture), null);
}
settings.Remove(setting.Key);
}
catch (Exception exception)
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, Resources.ParameterValueIsNotValid,
setting.Key, property.GetType().Name), exception);
}
}
}
}
}
