public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var values = new Identities(); IdentityType?currentKey = null; while (reader.Read()) { switch (reader.TokenType) { case JsonToken.PropertyName: IdentityType?key = GetEnum((string)reader.Value); if (!key.HasValue) { throw new SerializationException($"Did not recognize {reader.Value} as a valid Identity Type."); } currentKey = key.Value; break; case JsonToken.String: if (currentKey.HasValue && reader.Value != null) { values.Add(currentKey.Value, (string)reader.Value); } break; case JsonToken.EndObject: return(values); } } return(values); }
private static void CreateProtocolAndAdvise(Lifetime lifetime, List <ProtocolInstance> list, string solutionName) { try { var dispatcher = MainThreadDispatcher.Instance; var riderProtocolController = new RiderProtocolController(dispatcher, lifetime); list.Add(new ProtocolInstance(riderProtocolController.Wire.Port, solutionName)); #if !NET35 var serializers = new Serializers(lifetime, null, null); #else var serializers = new Serializers(); #endif var identities = new Identities(IdKind.Server); MainThreadDispatcher.AssertThread(); var protocol = new Protocol("UnityEditorPlugin" + solutionName, serializers, identities, MainThreadDispatcher.Instance, riderProtocolController.Wire, lifetime); riderProtocolController.Wire.Connected.WhenTrue(lifetime, connectionLifetime => { ourLogger.Log(LoggingLevel.VERBOSE, "Create UnityModel and advise for new sessions..."); var model = new EditorPluginModel(connectionLifetime, protocol); AdviseUnityActions(model, connectionLifetime); AdviseEditorState(model); OnModelInitialization(new UnityModelAndLifetime(model, connectionLifetime)); AdviseRefresh(model); InitEditorLogPath(model); model.UnityProcessId.SetValue(Process.GetCurrentProcess().Id); model.UnityApplicationData.SetValue(new UnityApplicationData( EditorApplication.applicationPath, EditorApplication.applicationContentsPath, UnityUtils.UnityApplicationVersion)); model.ScriptingRuntime.SetValue(UnityUtils.ScriptingRuntime); if (UnityUtils.UnityVersion >= new Version(2018, 2)) { model.ScriptCompilationDuringPlay.Set(EditorPrefsWrapper.ScriptChangesDuringPlayOptions); } else { model.ScriptCompilationDuringPlay.Set((int)PluginSettings.AssemblyReloadSettings); } AdviseShowPreferences(model, connectionLifetime, ourLogger); AdviseGenerateUISchema(model); AdviseExitUnity(model); GetBuildLocation(model); AdviseRunMethod(model); GetInitTime(model); ourLogger.Verbose("UnityModel initialized."); var pair = new ModelWithLifetime(model, connectionLifetime); connectionLifetime.OnTermination(() => { UnityModels.Remove(pair); }); UnityModels.Add(pair); }); } catch (Exception ex) { ourLogger.Error("Init Rider Plugin " + ex); } }
private void CheckUsername(string username) { if (Identities.Any(x => String.Equals(x.Username, username, StringComparison.InvariantCultureIgnoreCase))) { throw new DuplicateUsernameException("The username '" + username + "' is already in use."); } }
private void AddIdentity(string name, string version, string hintPath) { if (name.IsNullOrEmpty()) { throw new ArgumentNullException("name"); } foreach (char c in name) { if (!char.IsLetterOrDigit(c) && c != '.' && c != '_') { throw new Exception(PlugInConst.ManifestIdentity + " name contains invalid character: '" + c + "'"); } } Version v = PlugInReference.ParseVersion(version, hintPath); if (PrimaryVersion == null) { PrimaryVersion = v; } if (PrimaryIdentity == null) { PrimaryIdentity = name; } Identities.Add(name, v); }
private void InitDbIdentity() { if (_dbId == null) { lock (_lockObject) { if (_dbId == null) { var identity = Identities.FirstOrDefault(); if (identity == null) { var guid = Guid.NewGuid().ToByteArray(); identity = new IdentityEntity() { Data = guid }; Identities.Add(identity); SaveChanges(); } _dbId = identity.Data; Console.WriteLine($"SQLite ID:{_dbId.ToHexString()}"); } } } }
public async Task <IActionResult> ForgotPassword(string email) { if (ModelState.IsValid) { var user = await Identities.GetUserByUsernameAsync(email); if (user == null) { return(RedirectToAction("ForgotPasswordConfirm")); } // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713 // Send an email with this link var result = await Identities.GeneratePasswordResetTokenAsync(user); var callbackUrl = Url.Action("ForgotPasswordCallback", "Account", new { userId = user.Id, code = result.Token }, HttpContext.Request.Scheme); await Communication.SendForgotPassword(user, callbackUrl); return(RedirectToAction("ForgotPasswordConfirm")); } else { var invalidProperty = ModelState.First(x => x.Value.ValidationState == ModelValidationState.Invalid); SetUserError("תקלה במידע שהתקבל", invalidProperty.Value.Errors.FirstOrDefault()?.ErrorMessage ?? "אנא נסו שוב"); return(View()); } }
public IActionResult GetListByUsrName(int pageIndex, int rowCount, string userName, string usrType) { /*判断是否合法*/ if (ModelState.IsValid) { try { if (string.IsNullOrEmpty(usrType)) { usrType = "2,3"; } IList <HelpCenter.Model.Usr> usrList = HelpCenter.BLL.Usr.GetListByUsrName(pageIndex, rowCount, out int _totalCount, out int _pageCount, userName, usrType, User.Identities.First(u => u.IsAuthenticated).FindFirst("UsrDeptId").Value); return(null == usrList ? Ok(new { result = false, tips = ResponseMessageTips.MSG_USR_INFO_NO_FOUND }) : Ok(new { result = true, tips = ResponseMessageTips.MSG_PROCESS_SUCCESS, data = new { totalCount = _totalCount, pageCount = _pageCount, info = usrList } })); } catch (Exception e) { return(Ok(new { result = false, tips = ResponseMessageTips.MSG_PROCESS_EXCEPTION + e.Message.ToString() })); } } return(Ok(new { result = false, tips = ResponseMessageTips.MSG_PROCESS_DATA_FORMAT_ERROR })); }
public async Task <IActionResult> Login(AccountLoginViewModel model) { var returnModel = new AccountViewModel() { Login = model }; if (ModelState.IsValid) { var result = await Identities.LoginAsync(model.Email, model.Password, true); if (result.IsSuccess) { var cookieConsent = HttpContext.Features.Get <ITrackingConsentFeature>(); cookieConsent.GrantConsent(); return(RedirectToAction("Index", "Personal", new { area = "Participant" })); } else { SetUserError("כשלון בהתחברות ", result.Details); return(View("LoginOrRegister", returnModel)); } } else { var invalidProperty = ModelState.First(x => x.Value.ValidationState == ModelValidationState.Invalid); SetUserError("תקלה במידע שהתקבל", invalidProperty.Value.Errors.FirstOrDefault()?.ErrorMessage ?? "אנא נסו שוב"); return(View("LoginOrRegister", returnModel)); } // If we got this far, something failed, redisplay form return(View("LoginOrRegister", model)); }
public void Render(Message message, Identities source) { foreach (var nestedRenderer in _nestedRenderers) { nestedRenderer.Render(message, source); } }
public void Render(Message message, Identities source) { if (message.Level >= _level) { _nestedRenderer.Render(message, source); } }
public ICommand ToCommand(Object serial, Stream stream, Encoding encoding) { if (stream == null) { return(default(ICommand)); } CommandIdentifier identifier = null; if (Identities != null && Identities.ContainsKey(serial)) { identifier = (CommandIdentifier)Identities [serial]; } if (identifier == null) { return(default(ICommand)); } Object command = null; // create a reader, using the specific encoding of the socket using (StreamReader reader = new StreamReader(stream, encoding)) { //XmlDocument xmldoc = new XmlDocument(); //xmldoc.Load (reader); // create a serializer for the given object type. XmlSerializer serializer = new XmlSerializer(identifier.CommandType); //XmlWriterSettings settings = new XmlWriterSettings(); //settings.Encoding = encoding; //settings.Indent = false; //XmlReader reader = XmlReader.Create(stream, settings); command = serializer.Deserialize(reader); //xmldoc. /* * using (XmlReader xmlr = XmlReader.Create(reader)) { * XmlDocument xml = new XmlDocument(); * * } */ // // serializer lock, making it thread safe. // lock (SerializerLock) { // c = Serializer.Deserialize(reader); // reader.Close(); // } } if (!(command is ICommand)) { // TODO throw exception return(default(ICommand)); } return((ICommand)command); }
private static void Init() { var projectDirectory = Directory.GetParent(Application.dataPath).FullName; var projectName = Path.GetFileName(projectDirectory); SlnFile = Path.GetFullPath($"{projectName}.sln"); InitializeEditorInstanceJson(); // for the case when files were changed and user just alt+tab to unity to make update, we want to fire CsprojAssetPostprocessor.OnGeneratedCSProjectFiles(); Log.DefaultFactory = new RiderLoggerFactory(); var lifetimeDefinition = Lifetimes.Define(EternalLifetime.Instance); var lifetime = lifetimeDefinition.Lifetime; AppDomain.CurrentDomain.DomainUnload += (EventHandler)((_, __) => { ourLogger.Verbose("lifetimeDefinition.Terminate"); lifetimeDefinition.Terminate(); }); Debug.Log($"Rider plugin initialized. Logs are in: {LogPath}. Current Logging Level {PluginSettings.SelectedLoggingLevel}. Change it in Unity Preferences -> Rider."); try { var riderProtocolController = new RiderProtocolController(MainThreadDispatcher.Instance, lifetime); var serializers = new Serializers(); var identities = new Identities(IdKind.Server); MainThreadDispatcher.AssertThread(); riderProtocolController.Wire.Connected.View(lifetime, (lt, connected) => { if (connected) { var protocol = new Protocol(serializers, identities, MainThreadDispatcher.Instance, riderProtocolController.Wire); ourLogger.Log(LoggingLevel.VERBOSE, "Create UnityModel and advise for new sessions..."); ourModel.Value = CreateModel(protocol, lt); } else { ourModel.Value = null; } }); } catch (Exception ex) { ourLogger.Error("Init Rider Plugin " + ex); } ourAssetHandler = new OnOpenAssetHandler(ourModel, ourRiderPathLocator, ourPluginSettings, SlnFile); ourInitialized = true; }
/// <summary> /// Metoda wykonywana za każdym razem gdy użytkownik zmieni zaznaczenie wiersza w DataGridViewIdentitys /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void dataGridViewIdentities_SelectionChanged(object sender, EventArgs e) { // Pobranie zaznaczonych danych z tabeli Identities identities = (Identities)dataGridViewIdentities.CurrentRow.DataBoundItem; // Zmiana wyświetlanego zdjęcia pictureBoxPhoto.Image = ConvertByteArrayToImage(identities.Image); }
public void Render(Message message, Identities source) { _writerProvider.Value.WriteLine("<tr class='item {0}'>", message.Level); _writerProvider.Value.WriteLine("<td>{0}</td>", message.Level); _writerProvider.Value.WriteLine("<td>{0}</td>", string.Join(" -> ", source.Items.Select(id => id.Value).ToArray())); _writerProvider.Value.WriteLine("<td><pre>{0}</pre></td>", message.Text); _writerProvider.Value.WriteLine("</tr>"); }
/// <inheritdoc/> public override string ToString() { return(string.Format( "Delete from '{0}' where ({1}){2}", SourceTablePath, string.Join(" and ", Identities.Select(pair => pair.ToString()).ToArray()), PostCopy ? " (after data copying)" : string.Empty)); }
/// <inheritdoc/> public override string ToString() { return(string.Format( "Update '{0}' set ({1}) where ({2})", SourceTablePath, string.Join(", ", UpdateParameter.Select(pair => string.Format("{0}={1}", pair.First, pair.Second ?? "Default")) .ToArray()), string.Join(" and ", Identities.Select(pair => pair.ToString()).ToArray()))); }
private void SaveIdentities(string root) { Identities identities = new Identities(_applicationIdentity, _assemblyIdentity, _domainIdentity); using (FileStream fs = File.OpenWrite(root + ".storage")) { BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(fs, identities); fs.Close(); } }
private async Task RefreshAccounts() { Trace($"Refresh accounts"); var accounts = Identities.SelectMany(i => i.Accounts.Where(a => a.IsLive)); var tasks = accounts.Select(a => a.Refresh(this)); await Task.WhenAll(tasks); }
private static DteProtocolModel SetupModel(Lifetime lifetime, int port) { IScheduler scheduler = new SimpleInpaceExecutingScheduler(Logger.GetLogger <ConnectionManager>()); var server = new SocketWire.Client(lifetime, scheduler, port); var serializers = new Serializers(); var identities = new Identities(IdKind.Client); var protocol = new Protocol(Protocol, serializers, identities, scheduler, server, lifetime); return(new DteProtocolModel(lifetime, protocol)); }
public virtual DynamicJsonValue ToJson() { return(new DynamicJsonValue(GetType()) { [nameof(Documents)] = Documents.ToJson(), [nameof(RevisionDocuments)] = RevisionDocuments.ToJson(), [nameof(Tombstones)] = Tombstones.ToJson(), [nameof(Identities)] = Identities.ToJson(), [nameof(Indexes)] = Indexes.ToJson(), }); }
internal static void AddUserIdentities(Identities identities, IdentityApiRequest identityApiRequest) { if (identityApiRequest != null) { var userIdentities = identityApiRequest.UserIdentities; foreach (var identity in userIdentities) { identities[(IdentityType)identity.Key] = identity.Value; } } }
/// <inheritdoc/> public override string ToString() { return(string.Format( "Copy from '{0}' to '{1}' where ({2})", string.Join(", ", CopiedColumns.Select(pair => pair.First) .ToArray()), string.Join(", ", CopiedColumns.Select(pair => pair.Second) .ToArray()), string.Join(" and ", Identities.Select(pair => pair.ToString()) .ToArray()))); }
/// <summary> /// Change the Username of an Identity. /// </summary> public void ChangeUsername(Guid identityId, string username) { CheckUsername(username); var identity = Identities.FirstOrDefault(x => x.Id == identityId); if (identity == null) { throw new Exception("Identity does not belong to this System."); } identity.ChangeUsername(username); }
public override int GetHashCode() { unchecked { var hashCode = (_publicProperties != null ? _publicProperties.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Id != null ? Id.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (DisplayName != null ? DisplayName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (AvatarUrl != null ? AvatarUrl.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Identities != null ? Identities.GetHashCode() : 0); return(hashCode); } }
private int AddUpdateEntry(Update update, XDocument updateXmlDoc) { var newUpdateIndex = Identities.Count; Identities.Add(update.Identity); IdentityToIndex.Add(update.Identity, newUpdateIndex); IndexToIdentity.Add(newUpdateIndex, update.Identity); if (update is Detectoid) { UpdateTypeMap.Add(newUpdateIndex, (uint)UpdateType.Detectoid); Categories.TryAdd(update.Identity, update); } else if (update is Classification) { UpdateTypeMap.Add(newUpdateIndex, (uint)UpdateType.Classification); Categories.TryAdd(update.Identity, update); } else if (update is Product) { UpdateTypeMap.Add(newUpdateIndex, (uint)UpdateType.Product); Categories.TryAdd(update.Identity, update); } else if (update is SoftwareUpdate) { UpdateTypeMap.Add(newUpdateIndex, (uint)UpdateType.Software); Updates.TryAdd(update.Identity, update); } else if (update is DriverUpdate) { UpdateTypeMap.Add(newUpdateIndex, (uint)UpdateType.Driver); Updates.TryAdd(update.Identity, update); } ExtractAndIndexTitle(newUpdateIndex, updateXmlDoc); AddedUpdates.Add(newUpdateIndex, update); AddUpdateBundleInformation(newUpdateIndex, update.Identity, updateXmlDoc); AddPrerequisiteInformation(newUpdateIndex, update.Identity, updateXmlDoc); AddUpdateFileInformationToIndex(newUpdateIndex, update.Identity, updateXmlDoc); ExtractSupersedingInformation(newUpdateIndex, update.Identity, updateXmlDoc); if (update is DriverUpdate) { ExtractAndIndexDriverMetadata(newUpdateIndex, updateXmlDoc); } ExtractAndIndexKbArticle(newUpdateIndex, updateXmlDoc, update); return(newUpdateIndex); }
private IdentityRequest BuildIdentityRequest(IdentityApiRequest identityApiRequest) { var identityRequest = new IdentityRequest(); PopulateBaseIdentityRequest(identityRequest); var identities = new Identities(); AddDeviceIdentities(identities); AddUserIdentities(identities, identityApiRequest); identityRequest.KnownIdentities = identities; return(identityRequest); }
public async Task <IActionResult> Logout() { var myCookies = Request.Cookies.Keys; foreach (var cookie in myCookies) { Response.Cookies.Delete(cookie); } await Identities.LogoutAsync(Actor.Me.Id); return(RedirectToAction("Login")); }
private static void CreateProtocolAndAdvise(Lifetime lifetime, List <ProtocolInstance> list, string solutionFileName) { try { var dispatcher = MainThreadDispatcher.Instance; var riderProtocolController = new RiderProtocolController(dispatcher, lifetime); list.Add(new ProtocolInstance(riderProtocolController.Wire.Port, solutionFileName)); var serializers = new Serializers(); var identities = new Identities(IdKind.Server); MainThreadDispatcher.AssertThread(); riderProtocolController.Wire.Connected.WhenTrue(lifetime, connectionLifetime => { var protocol = new Protocol("UnityEditorPlugin", serializers, identities, MainThreadDispatcher.Instance, riderProtocolController.Wire); ourLogger.Log(LoggingLevel.VERBOSE, "Create UnityModel and advise for new sessions..."); var model = new EditorPluginModel(connectionLifetime, protocol); AdviseUnityActions(model, connectionLifetime); AdviseEditorState(model); OnModelInitialization(new UnityModelAndLifetime(model, connectionLifetime)); AdviseRefresh(model); InitEditorLogPath(model); AdviseScriptCompilationDuringPlay(model, connectionLifetime); model.UnityProcessId.Set(Process.GetCurrentProcess().Id); model.FullPluginPath.AdviseNotNull(connectionLifetime, AdditionalPluginsInstaller.UpdateSelf); model.ApplicationPath.SetValue(EditorApplication.applicationPath); model.ApplicationContentsPath.SetValue(EditorApplication.applicationContentsPath); model.ApplicationVersion.SetValue(Application.unityVersion); model.ScriptingRuntime.SetValue(UnityUtils.ScriptingRuntime); if (UnityUtils.UnityVersion >= new Version(2018, 2) && EditorPrefsWrapper.ScriptChangesDuringPlayOptions == 0) { model.NotifyIsRecompileAndContinuePlaying.Fire("General"); } else if (UnityUtils.UnityVersion < new Version(2018, 2) && PluginSettings.AssemblyReloadSettings == AssemblyReloadSettings.RecompileAndContinuePlaying) { model.NotifyIsRecompileAndContinuePlaying.Fire("Rider"); } ourLogger.Verbose("UnityModel initialized."); var pair = new ModelWithLifetime(model, connectionLifetime); connectionLifetime.AddAction(() => { UnityModels.Remove(pair); }); UnityModels.Add(pair); new UnityEventLogSender(ourLogEventCollector); }); } catch (Exception ex) { ourLogger.Error("Init Rider Plugin " + ex); } }
public void PlusSingleIdentity() { var first = new Identities(new Identity("1"), new Identity("2")); var second = new Identity("3"); var result = first + second; Assert.That(result.Items.Length, Is.EqualTo(3)); Assert.That(result.Items[0].Value, Is.EqualTo("1")); Assert.That(result.Items[1].Value, Is.EqualTo("2")); Assert.That(result.Items[2].Value, Is.EqualTo("3")); }
public Wallet() { Identities.Clear(); Identities.Add(new Identity { Label = "NewIdentity", IsDefault = true, Lock = false, Extra = null, Controls = new List <Control> { new Control("6Pxxxxxxxxx", "1") }, Ontid = "did:ont:AMxxxxxxxxxxxxxxxxxxxxxxx" }); Accounts.Add(new Account { Address = "TA6xxxxxxxxxxxx", Key = "6Pxxxxxxxxxxx", Hash = "sha256", Label = "NewAccount", PublicKey = "1202xxxxxxxxxxxxxx", SignatureScheme = "SHA256withECDSA", PasswordHash = "passwordhash" }); Scrypt = new Scrypt(16384, 8, 8); }
public async Task Seed() { if (await Identities.AnyAsync() || await PasswordAuthentications.AnyAsync()) { return; } await Identities.AddRangeAsync(Seeder.Identites); await PasswordAuthentications.AddRangeAsync(Seeder.PasswordAuths); await SaveChangesAsync(); }
public async void DeleteAccount(Account account) { Trace($"Delete {account}"); var manager = Identities.FirstOrDefault(i => i.AccountID == account.ManagerID); if (manager != null) { await manager.DeleteAccount(account, Connection); } Uncache(account); }
public void GivenMappingsBetweenTheFollowingTags(Table table) { var mappings = table.Rows.Select(row => (Source: row["Source"], From: row["From"], To: Guid.Parse(row["To"]))); var identitiesBySource = mappings.GroupBy(row => row.Source); var identitiesSource = identitiesBySource.ToDictionary(entry => entry.Key, entry => entry.ToDictionary(entryForSource => entryForSource.From, entryForSource => entryForSource.To)).ToDictionary(entry => entry.Key, entry => new TimeSeriesByTag(entry.Value)); var identities = new Identities(identitiesSource); _container.RegisterInstanceAs <Identities>(identities); }
public async Task <IActionResult> Register(AccountRegisterViewModel model) { var returnModel = new AccountViewModel() { Register = model }; if (ModelState.IsValid) { var participant = new LongTermParticipant { YearOfBirth = model.YearOfBirth, UserName = model.Email, FullName = model.FullName, Email = model.Email, IsAllowingPromotions = model.IsAllowingPromotions, PhoneNumber = model.PhoneNumber, }; var addResult = await Identities.AddNewParticipant(participant, model.Password); if (addResult.IsSuccess) { await Communication.SendWelcomeMessageAsync(participant); var signInResult = await Identities.LoginAsync(model.Email, model.Password, true); if (signInResult.IsSuccess) { var cookieConsent = HttpContext.Features.Get <ITrackingConsentFeature>(); cookieConsent.GrantConsent(); return(RedirectToAction("Index", "Personal", new { area = "Participant" })); } else { SetUserError("כשלון בהתחברות לאחר רישום", signInResult.Details); return(View("LoginOrRegister", returnModel)); } } else { SetUserError("תקלה ביצירת משתתף", addResult.Errors.FirstOrDefault()); return(View("LoginOrRegister", returnModel)); } } else { var invalidProperty = ModelState.First(x => x.Value.ValidationState == ModelValidationState.Invalid); SetUserError("תקלה במידע שהתקבל", invalidProperty.Value.Errors.FirstOrDefault()?.ErrorMessage ?? "אנא נסו שוב"); return(View("LoginOrRegister", returnModel)); } }
private TaskContext( IResultsStorage results, IExecutionStrategy executionStrategy, Identity identity, ILogRenderer logRenderer, IDirectory workDirectory, IEnvironment environment, ITaskInterceptor interceptor, Identities identitiesTail) { _identity = identity; _results = results; _executionStrategy = executionStrategy; _logRenderer = logRenderer; _workDirectory = workDirectory; _environment = environment; _interceptor = interceptor; _identitiesTail = identitiesTail; _log = new LogHelper(message => logRenderer.Render(message, GetFullIdentitiesPath())); }
public Layer[] Compose(RegisteredTasks map, Identities filter) { var allTasks = GetAllTasks(map, filter); var result = new List<Layer>(); while (allTasks.Any()) { var layerTasks = allTasks.Where(task => AllDependenciesResolved(map, task.Id, result)); var layer = new Layer(layerTasks.Select(x => new ExecutableWithIdentity(x.Task, x.Id)).ToArray()); if (layer.IsEmpty) { throw new Exception(GetErrorMessage(allTasks, result)); } result.Add(layer); allTasks = allTasks.Where(item => !layer.Contains(item.Task)).ToList(); } return result.ToArray(); }
private static List<ExecutableWithIdentity> GetAllTasks(RegisteredTasks map, Identities filter) { if (filter.IsEmpty) { return map.Transform((id, task) => new ExecutableWithIdentity(task.Task, id)).ToList(); } List<ExecutableWithIdentity> result = new List<ExecutableWithIdentity>(); Identities currentTasks = filter; while (true) { if (currentTasks.IsEmpty) { return result; } int oldResultSize = result.Count; IEnumerable<ExecutableWithIdentity> iterationDependencies = map.Transform(currentTasks, (id, task) => new ExecutableWithIdentity(task.Task, id)); foreach (ExecutableWithIdentity dependency in iterationDependencies) { if (!result.Any(x => x.Id == dependency.Id)) { result.Add(dependency); } } int newResultSize = result.Count; if (newResultSize == oldResultSize) { return result; } currentTasks = new Identities(currentTasks .Items .SelectMany(task => map[task].Dependencies.Items) .ToArray()); } }
public void Render(Message message, Identities source) { lock (_lockObject) { var level = message.Level; if (_lastSource == null || !Equals(_lastSource, source)) { for (int index = 0; index < source.Items.Length; index++) { Identity identity = source.Items[index]; WriteColored("[", ConsoleColor.DarkMagenta); WriteColored(identity.Value, ConsoleColor.DarkMagenta); WriteColored("]", ConsoleColor.DarkMagenta); if (index < source.Items.Length - 1) { WriteColored("->", ConsoleColor.DarkCyan); } } Console.WriteLine(); } var lines = message.Text.Split(new[] { Environment.NewLine }, StringSplitOptions.None).ToList(); var procesedLines = new List<string>(); const int fullIndentSize = 8; var maxWidth = _consoleWidth - fullIndentSize - 1; foreach (var line in lines) { var currentLine = line; while (currentLine.Length > maxWidth) { procesedLines.Add(currentLine.Substring(0, maxWidth)); currentLine = currentLine.Substring(maxWidth); } procesedLines.Add(currentLine); } if (procesedLines.Count > 0) { var levelString = " " + level.ToString().ToUpper(); WriteColored(levelString, ConsoleColor.DarkGray); Console.Write(new string(' ', fullIndentSize - levelString.Length)); WriteColored(procesedLines[0], GetColorForLevel(level)); Console.WriteLine(); if (procesedLines.Count > 1) { for (int i = 1; i < procesedLines.Count; i++) { Console.Write(new string(' ', fullIndentSize)); WriteColored(procesedLines[i], GetColorForLevel(level)); Console.WriteLine(); } } } else { Console.WriteLine(); } _lastSource = source; } }
private IEnumerable<Layer> ComposeWithFilter(TaskMap map, Identities filter) { return new SimpleLayersComposer().Compose(new RegisteredTasks(map.Map, null, Identities.Empty), filter); }
private IEnumerable<Layer> ComposeWithAllTasksAsFilter(TaskMap map) { var startupTaskIds = new Identities(map.Map.Keys.ToArray()); return new SimpleLayersComposer().Compose(new RegisteredTasks(map.Map, null, Identities.Empty), startupTaskIds); }
private void SaveIdentities (string root) { Identities identities = new Identities (_applicationIdentity, _assemblyIdentity, _domainIdentity); BinaryFormatter formatter = new BinaryFormatter (); mutex.WaitOne (); try { using (FileStream fs = File.Create (root + ".storage")) { formatter.Serialize (fs, identities); } } finally { mutex.ReleaseMutex (); } }