/// <summary> /// /// </summary> public static void LogDeviceInfo() { using (var service = new LoggingService(ApplicationName)) { service.Enable(); service.WriteDiagnostics(); service.Dispose(); } }
public override void OnException(ExceptionContext filterContext) { if (filterContext.ExceptionHandled || !filterContext.HttpContext.IsCustomErrorEnabled) { return; } if (new HttpException(null, filterContext.Exception).GetHttpCode() != 500) { return; } if (!ExceptionType.IsInstanceOfType(filterContext.Exception)) { return; } var controllerName = (string)filterContext.RouteData.Values["controller"]; var actionName = (string)filterContext.RouteData.Values["action"]; // if the request is AJAX return JSON else view. if (filterContext.HttpContext.Request.Headers["X-Requested-With"] == "XMLHttpRequest") { filterContext.Result = new JsonResult { JsonRequestBehavior = JsonRequestBehavior.AllowGet, Data = new { error = true, message = filterContext.Exception.Message } }; } else { var model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName); filterContext.Result = new ViewResult { ViewName = View, MasterName = Master, ViewData = new ViewDataDictionary(model), TempData = filterContext.Controller.TempData }; } // log the error by using your own method string message = string.Format("Controller Name : {0}, Action Method: {1}, Error Message :{2}", controllerName, actionName, filterContext.Exception.Message); ILogger logService = new LoggingService(); logService.Error(message, filterContext.Exception); filterContext.ExceptionHandled = true; filterContext.HttpContext.Response.Clear(); filterContext.HttpContext.Response.StatusCode = 500; filterContext.HttpContext.Response.TrySkipIisCustomErrors = true; }
public void WritingAnErrorMessageToTheDatabaseShouldStoreAnErrorMessage() { using (var source = new TestLoggingSource()) { var before = source.ErrorLogQuery().Count(); var loggingService = new LoggingService(source); loggingService.Log("Test", LogLevel.Error); var after = source.ErrorLogQuery().Count(); Assert.IsTrue(after == before + 1); } }
public void WritingAnAuditMessageToTheDatabaseShouldStoreAnAuditMessage() { using (var source = new TestLoggingSource()) { var before = source.AuditLogQuery().Count(); var loggingService = new LoggingService(source); loggingService.LogToAudit("Test", "AuditTest"); var after = source.AuditLogQuery().Count(); Assert.IsTrue(after == before + 1); } }
/// <summary> /// 记录错误日志 /// </summary> /// <param name="message"></param> /// <param name="e"></param> /// <param name="isWriteDebug"></param> public static void Log(string message, Exception e, bool isWriteDebug) { using (var service = new LoggingService(ApplicationName)) { service.Enable(); service.Write(e.Message); service.Dispose(); } if (isWriteDebug) { WriteDebug(message); } }
static void RegisterLoggingService(SPFeatureReceiverProperties properties) { SPSecurity.RunWithElevatedPrivileges(delegate() { SPFarm farm = properties.Definition.Farm; if (farm != null) { LoggingService service = LoggingService.Local; if (service == null) { service = new LoggingService(); service.Update(); if (service.Status != SPObjectStatus.Online) service.Provision(); } //foreach (SPServer server in farm.Servers) //{ // RegistryKey baseKey = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, server.Address); // if (baseKey != null) // { // RegistryKey eventLogKey = baseKey.OpenSubKey(EventLogApplicationRegistryKeyPath, true); // if (eventLogKey != null) // { // RegistryKey loggingServiceKey = eventLogKey.OpenSubKey(LoggingService.AreaName); // if (loggingServiceKey == null) // { // loggingServiceKey = eventLogKey.CreateSubKey(LoggingService.AreaName, RegistryKeyPermissionCheck.ReadWriteSubTree); // loggingServiceKey.SetValue("EventMessageFile", @"C:\Windows\Microsoft.NET\Framework\v2.0.50727\EventLogMessages.dll", RegistryValueKind.String); // } // } // } //} } }); }
internal void DoReSmartIndent(int cursor) { SafeUpdateIndentEngine(cursor); if (stateTracker.LineBeganInsideVerbatimString || stateTracker.LineBeganInsideMultiLineComment || stateTracker.IsInsidePreprocessorDirective) { return; } if (DefaultSourceEditorOptions.Instance.IndentStyle == IndentStyle.Auto) { Editor.FixVirtualIndentation(); return; } var line = Editor.GetLineByOffset(cursor); // Get context to the end of the line w/o changing the main engine's state var curTracker = stateTracker.Clone(); try { for (int max = cursor; max < line.EndOffset; max++) { curTracker.Push(Editor.GetCharAt(max)); } } catch (Exception e) { LoggingService.LogError("Exception during indentation", e); } int pos = line.Offset; string curIndent = line.GetIndentation(Editor); int nlwsp = curIndent.Length; int offset = cursor > pos + nlwsp ? cursor - (pos + nlwsp) : 0; if (!stateTracker.LineBeganInsideMultiLineComment || (nlwsp < line.LengthIncludingDelimiter && Editor.GetCharAt(line.Offset + nlwsp) == '*')) { // Possibly replace the indent string newIndent = curTracker.ThisLineIndent; int newIndentLength = newIndent.Length; if (newIndent != curIndent) { if (CompletionWindowManager.IsVisible) { if (pos < CompletionWindowManager.CodeCompletionContext.TriggerOffset) { CompletionWindowManager.CodeCompletionContext.TriggerOffset -= nlwsp; } } newIndentLength = newIndent.Length; Editor.ReplaceText(pos, nlwsp, newIndent); //textEditorData.CommitLineUpdate (textEditorData.CaretLine); CompletionWindowManager.HideWindow(); } pos += newIndentLength; } else { pos += curIndent.Length; } pos += offset; Editor.FixVirtualIndentation(); }
public AuthenticodeSigner(X509Certificate2 certificate, LoggingService log) { Certificate = certificate; _loggingService = log; }
internal static void SearchReplace(string findPattern, string replacePattern, Scope scope, FilterOptions options, System.Action UpdateStopButton) { if (find != null && find.IsRunning) { if (!MessageService.Confirm(GettextCatalog.GetString("There is a search already in progress. Do you want to stop it?"), AlertButton.Stop)) { return; } } searchTokenSource.Cancel(); if (scope == null) { return; } find = new FindReplace(); string pattern = findPattern; if (String.IsNullOrEmpty(pattern)) { return; } if (!find.ValidatePattern(options, pattern)) { MessageService.ShowError(GettextCatalog.GetString("Search pattern is invalid")); return; } if (replacePattern != null && !find.ValidatePattern(options, replacePattern)) { MessageService.ShowError(GettextCatalog.GetString("Replace pattern is invalid")); return; } var cancelSource = new CancellationTokenSource(); searchTokenSource = cancelSource; var token = cancelSource.Token; currentTask = Task.Run(delegate { using (SearchProgressMonitor searchMonitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, cancellationTokenSource: cancelSource)) { searchMonitor.PathMode = scope.PathMode; searchMonitor.ReportStatus(scope.GetDescription(options, pattern, null)); if (UpdateStopButton != null) { Application.Invoke(delegate { UpdateStopButton(); }); } DateTime timer = DateTime.Now; string errorMessage = null; try { var results = new List <SearchResult> (); foreach (SearchResult result in find.FindAll(scope, searchMonitor, pattern, replacePattern, options, token)) { if (token.IsCancellationRequested) { return; } results.Add(result); } searchMonitor.ReportResults(results); } catch (Exception ex) { errorMessage = ex.Message; LoggingService.LogError("Error while search", ex); } string message; if (errorMessage != null) { message = GettextCatalog.GetString("The search could not be finished: {0}", errorMessage); searchMonitor.ReportError(message, null); } else if (searchMonitor.CancellationToken.IsCancellationRequested) { message = GettextCatalog.GetString("Search cancelled."); searchMonitor.ReportWarning(message); } else { string matches = string.Format(GettextCatalog.GetPluralString("{0} match found", "{0} matches found", find.FoundMatchesCount), find.FoundMatchesCount); string files = string.Format(GettextCatalog.GetPluralString("in {0} file.", "in {0} files.", find.SearchedFilesCount), find.SearchedFilesCount); message = GettextCatalog.GetString("Search completed.") + Environment.NewLine + matches + " " + files; searchMonitor.ReportSuccess(message); } searchMonitor.ReportStatus(message); searchMonitor.Log.WriteLine(GettextCatalog.GetString("Search time: {0} seconds."), (DateTime.Now - timer).TotalSeconds); } if (UpdateStopButton != null) { Application.Invoke(delegate { UpdateStopButton(); }); } }); }
public ServiceBase(IServiceProvider provider) { _log = provider.GetRequiredService <LoggingService>(); _log.Log($"{ this.GetType().Name } created"); }
public ToolboxService() { LoggingService.Info("Create Tolboxservice"); }
public ActionResult Show(string slug, int?p) { // Set the page index var pageIndex = p ?? 1; using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork()) { // Get the topic var topic = _topicService.GetTopicBySlug(slug); if (topic != null) { // Note: Don't use topic.Posts as its not a very efficient SQL statement // Use the post service to get them as it includes other used entities in one // statement rather than loads of sql selects var sortQuerystring = Request.QueryString[AppConstants.PostOrderBy]; var orderBy = !string.IsNullOrEmpty(sortQuerystring) ? EnumUtils.ReturnEnumValueFromString <PostOrderBy>(sortQuerystring) : PostOrderBy.Standard; // Store the amount per page var amountPerPage = SettingsService.GetSettings().PostsPerPage; if (sortQuerystring == AppConstants.AllPosts) { // Overide to show all posts amountPerPage = int.MaxValue; } // Get the posts var posts = _postService.GetPagedPostsByTopic(pageIndex, amountPerPage, int.MaxValue, topic.Id, orderBy); // Get the topic starter post var topicStarter = _postService.GetTopicStarterPost(topic.Id); // Get the permissions for the category that this topic is in var permissions = RoleService.GetPermissions(topic.Category, UsersRole); // If this user doesn't have access to this topic then // redirect with message if (permissions[AppConstants.PermissionDenyAccess].IsTicked) { return(ErrorToHomePage(LocalizationService.GetResourceString("Errors.NoPermission"))); } // See if the user has subscribed to this topic or not var isSubscribed = UserIsAuthenticated && (_topicNotificationService.GetByUserAndTopic(LoggedOnUser, topic).Any()); // Populate the view model for this page var viewModel = new ShowTopicViewModel { Topic = topic, Posts = posts, PageIndex = posts.PageIndex, TotalCount = posts.TotalCount, Permissions = permissions, User = LoggedOnUser, IsSubscribed = isSubscribed, UserHasAlreadyVotedInPoll = false, TopicStarterPost = topicStarter }; // If there is a quote querystring var quote = Request["quote"]; if (!string.IsNullOrEmpty(quote)) { try { // Got a quote var postToQuote = _postService.Get(new Guid(quote)); viewModel.PostContent = postToQuote.PostContent; } catch (Exception ex) { LoggingService.Error(ex); } } // See if the topic has a poll, and if so see if this user viewing has already voted if (topic.Poll != null) { // There is a poll and a user // see if the user has voted or not var votes = topic.Poll.PollAnswers.SelectMany(x => x.PollVotes).ToList(); if (UserIsAuthenticated) { viewModel.UserHasAlreadyVotedInPoll = (votes.Count(x => x.User.Id == LoggedOnUser.Id) > 0); } viewModel.TotalVotesInPoll = votes.Count(); } // User has permission lets update the topic view count // but only if this topic doesn't belong to the user looking at it var addView = !(UserIsAuthenticated && LoggedOnUser.Id == topic.User.Id); if (!BotUtils.UserIsBot() && addView) { // Cool, user doesn't own this topic topic.Views = (topic.Views + 1); try { unitOfWork.Commit(); } catch (Exception ex) { LoggingService.Error(ex); } } return(View(viewModel)); } } return(ErrorToHomePage(LocalizationService.GetResourceString("Errors.GenericMessage"))); }
void ReportExtensionError(Exception ex) { LoggingService.LogInternalError("Error in text editor extension chain", ex); }
public static TargetFramework FromFrameworkDirectory(TargetFrameworkMoniker moniker, FilePath dir) { var fxList = dir.Combine("RedistList", "FrameworkList.xml"); if (!File.Exists(fxList)) { return(null); } var fx = new TargetFramework(moniker); using (var reader = System.Xml.XmlReader.Create(fxList)) { if (!reader.ReadToDescendant("FileList")) { throw new Exception("Missing FileList element"); } //not sure what this is for //if (reader.MoveToAttribute ("Redist") && reader.ReadAttributeValue ()) // redist = reader.ReadContentAsString (); if (reader.MoveToAttribute("Name") && reader.ReadAttributeValue()) { fx.name = reader.ReadContentAsString(); } if (reader.MoveToAttribute("RuntimeVersion") && reader.ReadAttributeValue()) { string runtimeVersion = reader.ReadContentAsString(); switch (runtimeVersion) { case "2.0": fx.clrVersion = ClrVersion.Net_2_0; break; case "4.0": fx.clrVersion = ClrVersion.Net_4_0; break; //The concept of "ClrVersion" breaks down hard after 4.5 and is essentially meaningless default: fx.clrVersion = ClrVersion.Net_4_5; break; } } if (reader.MoveToAttribute("ToolsVersion") && reader.ReadAttributeValue()) { string toolsVersion = reader.ReadContentAsString(); switch (toolsVersion) { case "2.0": fx.toolsVersion = TargetFrameworkToolsVersion.V2_0; break; case "3.5": fx.toolsVersion = TargetFrameworkToolsVersion.V3_5; break; case "4.0": fx.toolsVersion = TargetFrameworkToolsVersion.V4_0; break; case "4.5": fx.toolsVersion = TargetFrameworkToolsVersion.V4_5; break; default: LoggingService.LogInfo("Framework {0} has unknown ToolsVersion {1}", moniker, toolsVersion); return(null); } } if (reader.MoveToAttribute("IncludeFramework") && reader.ReadAttributeValue()) { string include = reader.ReadContentAsString(); if (!string.IsNullOrEmpty(include)) { fx.includesFramework = include; } } //this is a Mono-specific extension if (reader.MoveToAttribute("TargetFrameworkDirectory") && reader.ReadAttributeValue()) { string targetDir = reader.ReadContentAsString(); if (!string.IsNullOrEmpty(targetDir)) { targetDir = targetDir.Replace('\\', System.IO.Path.DirectorySeparatorChar); dir = fxList.ParentDirectory.Combine(targetDir).FullPath; } } var assemblies = new List <AssemblyInfo> (); if (reader.ReadToFollowing("File")) { do { var ainfo = new AssemblyInfo(); assemblies.Add(ainfo); if (reader.MoveToAttribute("AssemblyName") && reader.ReadAttributeValue()) { ainfo.Name = reader.ReadContentAsString(); } if (string.IsNullOrEmpty(ainfo.Name)) { throw new Exception("Missing AssemblyName attribute"); } if (reader.MoveToAttribute("Version") && reader.ReadAttributeValue()) { ainfo.Version = reader.ReadContentAsString(); } if (reader.MoveToAttribute("PublicKeyToken") && reader.ReadAttributeValue()) { ainfo.PublicKeyToken = reader.ReadContentAsString(); } if (reader.MoveToAttribute("Culture") && reader.ReadAttributeValue()) { ainfo.Culture = reader.ReadContentAsString(); } if (reader.MoveToAttribute("ProcessorArchitecture") && reader.ReadAttributeValue()) { ainfo.ProcessorArchitecture = (ProcessorArchitecture) Enum.Parse(typeof(ProcessorArchitecture), reader.ReadContentAsString(), true); } if (reader.MoveToAttribute("InGac") && reader.ReadAttributeValue()) { ainfo.InGac = reader.ReadContentAsBoolean(); } } while (reader.ReadToFollowing("File")); } else if (Directory.Exists(dir)) { foreach (var f in Directory.EnumerateFiles(dir, "*.dll")) { try { var an = SystemAssemblyService.GetAssemblyNameObj(dir.Combine(f)); var ainfo = new AssemblyInfo(); ainfo.Update(an); assemblies.Add(ainfo); } catch (BadImageFormatException ex) { LoggingService.LogError("Invalid assembly in framework '{0}': {1}{2}{3}", fx.Id, f, Environment.NewLine, ex.ToString()); } catch (Exception ex) { LoggingService.LogError("Error reading assembly '{0}' in framework '{1}':{2}{3}", f, fx.Id, Environment.NewLine, ex.ToString()); } } } fx.Assemblies = assemblies.ToArray(); } var supportedFrameworksDir = dir.Combine("SupportedFrameworks"); if (Directory.Exists(supportedFrameworksDir)) { foreach (var sfx in Directory.GetFiles(supportedFrameworksDir)) { fx.SupportedFrameworks.Add(SupportedFramework.Load(fx, sfx)); } } return(fx); }
public void LogError(string message, Exception ex) { LoggingService.LogError(message, ex); }
/// <summary> /// Initialize function called when this plugin is first loaded. /// </summary> /// <param name="logService"></param> /// <returns></returns> public override bool Initialize(LoggingService logService) { this.m_LoggingService = logService; return(true); }
internal static async Task UpdateFoldings(TextEditor Editor, ParsedDocument parsedDocument, DocumentLocation caretLocation, bool firstTime = false, CancellationToken token = default(CancellationToken)) { if (parsedDocument == null || !Editor.Options.ShowFoldMargin) { return; } // don't update parsed documents that contain errors - the foldings from there may be invalid. if (await parsedDocument.HasErrorsAsync(token)) { return; } try { var foldSegments = new List <IFoldSegment> (); foreach (FoldingRegion region in await parsedDocument.GetFoldingsAsync(token)) { if (token.IsCancellationRequested) { return; } var type = FoldingType.Unknown; bool setFolded = false; bool folded = false; //decide whether the regions should be folded by default switch (region.Type) { case FoldType.Member: type = FoldingType.TypeMember; break; case FoldType.Type: type = FoldingType.TypeDefinition; break; case FoldType.UserRegion: type = FoldingType.Region; setFolded = DefaultSourceEditorOptions.Instance.DefaultRegionsFolding; folded = true; break; case FoldType.Comment: type = FoldingType.Comment; setFolded = DefaultSourceEditorOptions.Instance.DefaultCommentFolding; folded = true; break; case FoldType.CommentInsideMember: type = FoldingType.Comment; setFolded = DefaultSourceEditorOptions.Instance.DefaultCommentFolding; folded = false; break; case FoldType.Undefined: setFolded = true; folded = region.IsFoldedByDefault; break; } var start = Editor.LocationToOffset(region.Region.Begin); var end = Editor.LocationToOffset(region.Region.End); var marker = Editor.CreateFoldSegment(start, end - start); foldSegments.Add(marker); marker.CollapsedText = region.Name; marker.FoldingType = type; //and, if necessary, set its fold state if (marker != null && setFolded && firstTime) { // only fold on document open, later added folds are NOT folded by default. marker.IsCollapsed = folded; continue; } if (marker != null && region.Region.Contains(caretLocation.Line, caretLocation.Column)) { marker.IsCollapsed = false; } } if (firstTime) { Editor.SetFoldings(foldSegments); } else { Application.Invoke(delegate { if (!token.IsCancellationRequested) { Editor.SetFoldings(foldSegments); } }); } } catch (OperationCanceledException) { } catch (Exception ex) { LoggingService.LogError("Unhandled exception in ParseInformationUpdaterWorkerThread", ex); } }
public void ReportError(string message, System.Exception ex) { LoggingService.LogError(message, ex); }
public async Task <bool> Execute(ProgressMonitor monitor, WorkspaceObject entry, ExecutionContext context, ConfigurationSelector configuration) { ProcessExecutionCommand cmd = CreateExecutionCommand(entry, configuration); monitor.Log.WriteLine(GettextCatalog.GetString("Executing: {0} {1}", cmd.Command, cmd.Arguments)); if (!Directory.Exists(cmd.WorkingDirectory)) { monitor.ReportError(GettextCatalog.GetString("Custom command working directory does not exist"), null); return(false); } ProcessAsyncOperation oper = null; OperationConsole console = null; var result = true; try { if (context != null) { if (externalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pauseExternalConsole, monitor.CancellationToken); } else { console = context.ConsoleFactory.CreateConsole(monitor.CancellationToken); } oper = context.ExecutionHandler.Execute(cmd, console); } else { if (externalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pauseExternalConsole, monitor.CancellationToken); oper = Runtime.ProcessService.StartConsoleProcess(cmd.Command, cmd.Arguments, cmd.WorkingDirectory, console, null); } else { oper = Runtime.ProcessService.StartProcess(cmd.Command, cmd.Arguments, cmd.WorkingDirectory, monitor.Log, monitor.Log, null, false).ProcessAsyncOperation; } } var stopper = monitor.CancellationToken.Register(oper.Cancel); await oper.Task; stopper.Dispose(); if (oper.ExitCode != 0) { monitor.ReportError("Custom command failed (exit code: " + oper.ExitCode + ")", null); } } catch (Win32Exception w32ex) { monitor.ReportError(GettextCatalog.GetString("Failed to execute custom command '{0}': {1}", cmd.Command, w32ex.Message), null); return(false); } catch (Exception ex) { LoggingService.LogError("Command execution failed", ex); throw new UserException(GettextCatalog.GetString("Command execution failed: {0}", ex.Message)); } finally { result = oper != null && oper.ExitCode == 0; if (console != null) { console.Dispose(); } } return(result); }
public ActionResult Create(CreateEditTopicViewModel viewModel) { using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork()) { var cats = _categoryService.GetAllowedEditCategories(UsersRole); if (cats.Count > 0) { if (ModelState.IsValid) { if (CheckCats(viewModel.Category, cats)) { var topic = new Topic(); var post = new Post(); topic.Name = viewModel.Name; topic.Category_Id = viewModel.Category; topic.IsLocked = viewModel.IsLocked; topic.IsSticky = viewModel.IsSticky; topic.MembershipUser_Id = LoggedOnReadOnlyUser.Id; topic.Id = post.Id; post.PostContent = viewModel.Content; post.MembershipUser_Id = LoggedOnReadOnlyUser.Id; post.Topic_Id = topic.Id; post.IsTopicStarter = true; try { _topicServic.Add(topic); _postSevice.Add(post); unitOfWork.Commit(); } catch (Exception ex) { LoggingService.Error(ex.Message); unitOfWork.Rollback(); } } else { //viewModel.Category = null; //No permission to create a Poll so show a message but create the topic //TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel //{ // Message = LocalizationService.GetResourceString("Errors.NoPermissionCatergory"), // MessageType = GenericMessages.info //}; ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Errors.CatergoryMessage")); } } viewModel.Categories = _categoryService.GetBaseSelectListCategories(cats); return(View(viewModel)); } return(ErrorToHomePage(LocalizationService.GetResourceString("Errors.NoPermission"))); } }
private void saveCodeActivity_ExecuteCode(object sender, EventArgs e) { IUser user = this.GetBinding <IUser>(BindingNames.User); var userFormLogin = GetBinding <IUserFormLogin>(BindingNames.UserFormLogin); var userFormLoginFromDatabase = user.GetUserFormLogin(); bool userValidated = true; ValidationResults validationResults = ValidationFacade.Validate(user); foreach (ValidationResult result in validationResults) { this.ShowFieldMessage($"{BindingNames.User}.{result.Key}", result.Message); userValidated = false; } List <CultureInfo> newActiveLocales = ActiveLocalesFormsHelper.GetSelectedLocalesTypes(this.Bindings).ToList(); List <CultureInfo> currentActiveLocales = UserSettings.GetActiveLocaleCultureInfos(user.Username, false).ToList(); string selectedActiveLocaleName = this.GetBinding <string>("ActiveLocaleName"); CultureInfo selectedActiveLocale = CultureInfo.CreateSpecificCulture(selectedActiveLocaleName); string systemPerspectiveEntityToken = EntityTokenSerializer.Serialize(AttachingPoint.SystemPerspective.EntityToken); List <Guid> newUserGroupIds = UserGroupsFormsHelper.GetSelectedUserGroupIds(this.Bindings); List <string> newSerializedEnitityTokens = ActivePerspectiveFormsHelper.GetSelectedSerializedEntityTokens(this.Bindings).ToList(); if (string.Compare(user.Username, UserSettings.Username, StringComparison.InvariantCultureIgnoreCase) == 0) { // Current user shouldn't be able to lock itself if (userFormLogin.IsLocked) { this.ShowMessage(DialogType.Message, Texts.EditUserWorkflow_EditErrorTitle, Texts.EditUserWorkflow_LockingOwnUserAccount); userValidated = false; } // Current user shouldn't be able to remove its own access to "System" perspective var groupsWithAccessToSystemPerspective = new HashSet <Guid>(GetGroupsThatHasAccessToPerspective(systemPerspectiveEntityToken)); if (!newSerializedEnitityTokens.Contains(systemPerspectiveEntityToken) && !newUserGroupIds.Any(groupsWithAccessToSystemPerspective.Contains)) { this.ShowMessage(DialogType.Message, Texts.EditUserWorkflow_EditErrorTitle, Texts.EditUserWorkflow_EditOwnAccessToSystemPerspective); userValidated = false; } } string newPassword = this.GetBinding <string>(BindingNames.NewPassword); if (newPassword == NotPassword || UserFormLoginManager.ValidatePassword(userFormLoginFromDatabase, newPassword)) { newPassword = null; } else { IList <string> validationMessages; if (!PasswordPolicyFacade.ValidatePassword(user, newPassword, out validationMessages)) { foreach (var message in validationMessages) { this.ShowFieldMessage(BindingNames.NewPassword, message); } userValidated = false; } } if (!userValidated) { return; } if (!userFormLogin.IsLocked) { userFormLogin.LockoutReason = (int)UserLockoutReason.Undefined; } else { bool wasLockedBefore = userFormLoginFromDatabase.IsLocked; if (!wasLockedBefore) { userFormLoginFromDatabase.LockoutReason = (int)UserLockoutReason.LockedByAdministrator; } } UpdateTreeRefresher updateTreeRefresher = this.CreateUpdateTreeRefresher(this.EntityToken); bool reloadUsersConsoles = false; using (var transactionScope = TransactionsFacade.CreateNewScope()) { DataFacade.Update(user); userFormLoginFromDatabase.Folder = userFormLogin.Folder; userFormLoginFromDatabase.IsLocked = userFormLogin.IsLocked; DataFacade.Update(userFormLoginFromDatabase); if (newPassword != null) { UserFormLoginManager.SetPassword(userFormLoginFromDatabase, newPassword); } string cultureName = this.GetBinding <string>("CultureName"); string c1ConsoleUiLanguageName = this.GetBinding <string>("C1ConsoleUiLanguageName"); UserSettings.SetUserCultureInfo(user.Username, CultureInfo.CreateSpecificCulture(cultureName)); UserSettings.SetUserC1ConsoleUiLanguage(user.Username, CultureInfo.CreateSpecificCulture(c1ConsoleUiLanguageName)); List <string> existingSerializedEntityTokens = UserPerspectiveFacade.GetSerializedEntityTokens(user.Username).ToList(); int intersectCount = existingSerializedEntityTokens.Intersect(newSerializedEnitityTokens).Count(); if ((intersectCount != newSerializedEnitityTokens.Count) || (intersectCount != existingSerializedEntityTokens.Count)) { UserPerspectiveFacade.SetSerializedEntityTokens(user.Username, newSerializedEnitityTokens); if (UserSettings.Username == user.Username) { reloadUsersConsoles = true; } } if (DataLocalizationFacade.ActiveLocalizationCultures.Any()) { foreach (CultureInfo cultureInfo in newActiveLocales) { if (!currentActiveLocales.Contains(cultureInfo)) { UserSettings.AddActiveLocaleCultureInfo(user.Username, cultureInfo); } } foreach (CultureInfo cultureInfo in currentActiveLocales) { if (!newActiveLocales.Contains(cultureInfo)) { UserSettings.RemoveActiveLocaleCultureInfo(user.Username, cultureInfo); } } if (selectedActiveLocale != null) { if (!selectedActiveLocale.Equals(UserSettings.GetCurrentActiveLocaleCultureInfo(user.Username))) { reloadUsersConsoles = true; } UserSettings.SetCurrentActiveLocaleCultureInfo(user.Username, selectedActiveLocale); } else if (UserSettings.GetActiveLocaleCultureInfos(user.Username).Any()) { UserSettings.SetCurrentActiveLocaleCultureInfo(user.Username, UserSettings.GetActiveLocaleCultureInfos(user.Username).First()); } } List <IUserUserGroupRelation> oldRelations = DataFacade.GetData <IUserUserGroupRelation>(f => f.UserId == user.Id).ToList(); IEnumerable <IUserUserGroupRelation> deleteRelations = from r in oldRelations where !newUserGroupIds.Contains(r.UserGroupId) select r; DataFacade.Delete(deleteRelations); foreach (Guid newUserGroupId in newUserGroupIds) { Guid groupId = newUserGroupId; if (oldRelations.Any(f => f.UserGroupId == groupId)) { continue; } var userUserGroupRelation = DataFacade.BuildNew <IUserUserGroupRelation>(); userUserGroupRelation.UserId = user.Id; userUserGroupRelation.UserGroupId = newUserGroupId; DataFacade.AddNew(userUserGroupRelation); } LoggingService.LogEntry("UserManagement", $"C1 Console user '{user.Username}' updated by '{UserValidationFacade.GetUsername()}'.", LoggingService.Category.Audit, TraceEventType.Information); transactionScope.Complete(); } if (UserSettings.GetCurrentActiveLocaleCultureInfo(user.Username) == null) { this.ShowFieldMessage(BindingNames.ActiveContentLanguage, "The user doesn't have permissions to access the language you selected here. Assign permissions so the user may access this."); this.ShowMessage(DialogType.Warning, "User missing permissions for language", "The user doesn't have permissions to access the language you selected as 'Active content language'."); } else { if (reloadUsersConsoles) { foreach (string consoleId in GetConsoleIdsOpenedByUser(user.Username)) { ConsoleMessageQueueFacade.Enqueue(new RebootConsoleMessageQueueItem(), consoleId); } } } SetSaveStatus(true); updateTreeRefresher.PostRefreshMesseges(user.GetDataEntityToken()); }
public void LogMessage(string messageFormat, params object[] args) { LoggingService.LogInfo(messageFormat, args); }
public ActionResult Create(CreateTopicViewModel topicViewModel) { if (ModelState.IsValid) { // Quick check to see if user is locked out, when logged in if (LoggedOnUser.IsLockedOut || LoggedOnUser.DisablePosting == true || !LoggedOnUser.IsApproved) { FormsAuthentication.SignOut(); return(ErrorToHomePage(LocalizationService.GetResourceString("Errors.NoAccess"))); } var successfullyCreated = false; var moderate = false; Category category; var topic = new Topic(); using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork()) { // Not using automapper for this one only, as a topic is a post and topic in one category = _categoryService.Get(topicViewModel.Category); // First check this user is allowed to create topics in this category var permissions = RoleService.GetPermissions(category, UsersRole); // Check this users role has permission to create a post if (permissions[AppConstants.PermissionDenyAccess].IsTicked || permissions[AppConstants.PermissionReadOnly].IsTicked || !permissions[AppConstants.PermissionCreateTopics].IsTicked) { // Throw exception so Ajax caller picks it up ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Errors.NoPermission")); } else { // We get the banned words here and pass them in, so its just one call // instead of calling it several times and each call getting all the words back var bannedWordsList = _bannedWordService.GetAll(); List <string> bannedWords = null; if (bannedWordsList.Any()) { bannedWords = bannedWordsList.Select(x => x.Word).ToList(); } topic = new Topic { Name = _bannedWordService.SanitiseBannedWords(topicViewModel.Name, bannedWords), Category = category, User = LoggedOnUser }; // See if the user has actually added some content to the topic if (!string.IsNullOrEmpty(topicViewModel.Content)) { // Check for any banned words topicViewModel.Content = _bannedWordService.SanitiseBannedWords(topicViewModel.Content, bannedWords); // See if this is a poll and add it to the topic if (topicViewModel.PollAnswers != null && topicViewModel.PollAnswers.Count > 0) { // Do they have permission to create a new poll if (permissions[AppConstants.PermissionCreatePolls].IsTicked) { // Create a new Poll var newPoll = new Poll { User = LoggedOnUser }; // Create the poll _pollService.Add(newPoll); // Save the poll in the context so we can add answers unitOfWork.SaveChanges(); // Now sort the answers var newPollAnswers = new List <PollAnswer>(); foreach (var pollAnswer in topicViewModel.PollAnswers) { // Attach newly created poll to each answer pollAnswer.Poll = newPoll; _pollAnswerService.Add(pollAnswer); newPollAnswers.Add(pollAnswer); } // Attach answers to poll newPoll.PollAnswers = newPollAnswers; // Save the new answers in the context unitOfWork.SaveChanges(); // Add the poll to the topic topic.Poll = newPoll; } else { //No permission to create a Poll so show a message but create the topic TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel { Message = LocalizationService.GetResourceString("Errors.NoPermissionPolls"), MessageType = GenericMessages.info }; } } // Update the users points score for posting _membershipUserPointsService.Add(new MembershipUserPoints { Points = SettingsService.GetSettings().PointsAddedPerPost, User = LoggedOnUser }); // Check for moderation if (category.ModerateTopics == true) { topic.Pending = true; moderate = true; } // Create the topic topic = _topicService.Add(topic); // Save the changes unitOfWork.SaveChanges(); // Now create and add the post to the topic _topicService.AddLastPost(topic, topicViewModel.Content); // Now check its not spam var akismetHelper = new AkismetHelper(SettingsService); if (!akismetHelper.IsSpam(topic)) { // Add the tags if any too if (!string.IsNullOrEmpty(topicViewModel.Tags)) { // Sanitise the tags topicViewModel.Tags = _bannedWordService.SanitiseBannedWords(topicViewModel.Tags, bannedWords); // Now add the tags _topicTagService.Add(topicViewModel.Tags.ToLower(), topic); } // Subscribe the user to the topic as they have checked the checkbox if (topicViewModel.SubscribeToTopic) { // Create the notification var topicNotification = new TopicNotification { Topic = topic, User = LoggedOnUser }; //save _topicNotificationService.Add(topicNotification); } try { unitOfWork.Commit(); if (!moderate) { successfullyCreated = true; } // Successful, add this post to the Lucene index if (_luceneService.CheckIndexExists()) { _luceneService.AddUpdate(_luceneService.MapToModel(topic)); } } catch (Exception ex) { unitOfWork.Rollback(); LoggingService.Error(ex); ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Errors.GenericMessage")); } } else { unitOfWork.Rollback(); ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Errors.PossibleSpam")); } } else { ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Errors.GenericMessage")); } } } using (UnitOfWorkManager.NewUnitOfWork()) { if (successfullyCreated) { // Success so now send the emails NotifyNewTopics(category); // Redirect to the newly created topic return(Redirect(string.Format("{0}?postbadges=true", topic.NiceUrl))); } if (moderate) { // Moderation needed // Tell the user the topic is awaiting moderation TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel { Message = LocalizationService.GetResourceString("Moderate.AwaitingModeration"), MessageType = GenericMessages.info }; return(RedirectToAction("Index", "Home")); } var allowedCategories = _categoryService.GetAllowedCategories(UsersRole).ToList(); if (allowedCategories.Any()) { topicViewModel.Categories = allowedCategories; } } return(View(topicViewModel)); } return(ErrorToHomePage(LocalizationService.GetResourceString("Errors.NoPermission"))); }
static void Debug(string text) { LoggingService.Debug(text); }
public TaskInfo CreateTaskInfo( string typeName, string assemblyName, ExpressionNode assemblyFile, string assemblyFileStr, string declaredInFile, int declaredAtOffset, IMSBuildEvaluationContext evaluationContext) { //ignore this, it's redundant if (assemblyName != null && assemblyName.StartsWith("Microsoft.Build.Tasks.v", StringComparison.Ordinal)) { return(null); } var tasks = GetTaskAssembly(assemblyName, assemblyFile, assemblyFileStr, declaredInFile, evaluationContext); IAssemblySymbol assembly = tasks?.assembly; if (assembly == null) { //TODO log this? return(null); } string asmShortName; if (string.IsNullOrEmpty(assemblyName)) { asmShortName = Path.GetFileNameWithoutExtension(tasks.Value.path); } else { asmShortName = new AssemblyName(assemblyName).Name; } INamedTypeSymbol FindType(INamespaceSymbol ns, string name) { foreach (var m in ns.GetMembers()) { switch (m) { case INamedTypeSymbol ts: if (ts.Name == name) { return(ts); } continue; case INamespaceSymbol childNs: var found = FindType(childNs, name); if (found != null) { return(found); } continue; } } return(null); } var type = assembly.GetTypeByMetadataName(typeName) ?? FindType(assembly.GlobalNamespace, typeName); if (type == null) { switch (typeName) { case "Microsoft.Build.Tasks.RequiresFramework35SP1Assembly": case "Microsoft.Build.Tasks.ResolveNativeReference": //we don't care about these, they're not present on Mac and they're just noise return(null); } LoggingService.LogWarning($"Did not resolve {typeName}"); return(null); } var ti = new TaskInfo( type.Name, RoslynHelpers.GetDescription(type), type.GetFullName(), assemblyName, assemblyFileStr, declaredInFile, declaredAtOffset); PopulateTaskInfoFromType(ti, type); return(ti); }
static void RunAsyncLoadTest() { while (true) { LoadData ld; lock (loadQueue) { if (loadQueue.Count == 0) { if (!Monitor.Wait(loadQueue, 5000, true)) { loaderRunning = false; return; } } ld = (LoadData)loadQueue.Dequeue(); } try { // If the information is cached in a file and it is up to date information, // there is no need to parse again the assembly. if (ld.TestInfoCachePath != null && File.Exists(ld.TestInfoCachePath)) { ld.InfoCache = TestInfoCache.Read(ld.TestInfoCachePath); NunitTestInfo info = ld.InfoCache.GetInfo(ld.Path); if (info != null) { ld.Info = info; ld.Callback(ld); continue; } } } catch (Exception ex) { LoggingService.LogError(ex.ToString()); } ExternalTestRunner runner = null; try { if (File.Exists(ld.Path)) { runner = (ExternalTestRunner)Runtime.ProcessService.CreateExternalProcessObject(typeof(ExternalTestRunner), false); ld.Info = runner.GetTestInfo(ld.Path, ld.SupportAssemblies); } } catch (Exception ex) { Console.WriteLine(ex); ld.Error = ex; } finally { try { if (runner != null) { runner.Dispose(); } } catch {} } try { ld.Callback(ld); } catch { } } }
protected virtual async Task<ICompletionDataList> HandleCodeCompletion ( CodeCompletionContext completionContext, bool forced, CancellationToken token) { var buf = this.Editor; // completionChar may be a space even if the current char isn't, when ctrl-space is fired t var currentLocation = new DocumentLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset); char currentChar = completionContext.TriggerOffset < 1? ' ' : buf.GetCharAt (completionContext.TriggerOffset - 1); char previousChar = completionContext.TriggerOffset < 2? ' ' : buf.GetCharAt (completionContext.TriggerOffset - 2); LoggingService.LogDebug ("Attempting completion for state '{0}'x{1}, previousChar='{2}'," + " currentChar='{3}', forced='{4}'", tracker.Engine.CurrentState, tracker.Engine.CurrentStateLength, previousChar, currentChar, forced); //closing tag completion if (tracker.Engine.CurrentState is XmlRootState && currentChar == '>') return ClosingTagCompletion (buf, currentLocation); // Auto insert '>' when '/' is typed inside tag state (for quick tag closing) //FIXME: avoid doing this when the next non-whitespace char is ">" or ignore the next ">" typed if (XmlEditorOptions.AutoInsertFragments && tracker.Engine.CurrentState is XmlTagState && currentChar == '/') { buf.InsertAtCaret (">"); return null; } //entity completion if (currentChar == '&' && (tracker.Engine.CurrentState is XmlRootState || tracker.Engine.CurrentState is XmlAttributeValueState)) { var list = new CompletionDataList (); //TODO: need to tweak semicolon insertion list.Add ("apos").Description = "'"; list.Add ("quot").Description = "\""; list.Add ("lt").Description = "<"; list.Add ("gt").Description = ">"; list.Add ("amp").Description = "&"; //not sure about these "completions". they're more like //shortcuts than completions but they're pretty useful list.Add ("'").CompletionText = "apos;"; list.Add ("\"").CompletionText = "quot;"; list.Add ("<").CompletionText = "lt;"; list.Add (">").CompletionText = "gt;"; list.Add ("&").CompletionText = "amp;"; var ecList = await GetEntityCompletions (token); list.AddRange (ecList); return list; } //doctype completion if (tracker.Engine.CurrentState is XmlDocTypeState) { if (tracker.Engine.CurrentStateLength == 1) { CompletionDataList list = await GetDocTypeCompletions (token); if (list != null && list.Count > 0) return list; } return null; } //attribute value completion //determine whether to trigger completion within attribute values quotes if ((Tracker.Engine.CurrentState is XmlAttributeValueState) //trigger on the opening quote && ((Tracker.Engine.CurrentStateLength == 1 && (currentChar == '\'' || currentChar == '"')) //or trigger on first letter of value, if unforced || (forced || Tracker.Engine.CurrentStateLength == 2))) { var att = (XAttribute)Tracker.Engine.Nodes.Peek (); if (att.IsNamed) { var attributedOb = Tracker.Engine.Nodes.Peek (1) as IAttributedXObject; if (attributedOb == null) return null; //if triggered by first letter of value or forced, grab those letters var result = await GetAttributeValueCompletions (attributedOb, att, token); if (result != null) { result.TriggerWordLength = Tracker.Engine.CurrentStateLength - 1; return result; } return null; } } //attribute name completion if ((forced && Tracker.Engine.Nodes.Peek () is IAttributedXObject && !tracker.Engine.Nodes.Peek ().IsEnded) || ((Tracker.Engine.CurrentState is XmlNameState && Tracker.Engine.CurrentState.Parent is XmlAttributeState) || Tracker.Engine.CurrentState is XmlTagState) && (Tracker.Engine.CurrentStateLength == 1 || forced)) { IAttributedXObject attributedOb = (Tracker.Engine.Nodes.Peek () as IAttributedXObject) ?? Tracker.Engine.Nodes.Peek (1) as IAttributedXObject; if (attributedOb == null) return null; //attributes if (attributedOb.Name.IsValid && (forced || (char.IsWhiteSpace (previousChar) && char.IsLetter (currentChar)))) { var existingAtts = new Dictionary<string,string> (StringComparer.OrdinalIgnoreCase); foreach (XAttribute att in attributedOb.Attributes) { existingAtts [att.Name.FullName] = att.Value ?? string.Empty; } var result = await GetAttributeCompletions (attributedOb, existingAtts, token); if (result != null) { if (!forced) result.TriggerWordLength = 1; return result; } return null; } } // if (Tracker.Engine.CurrentState is XmlRootState) { // if (line < 3) { // cp.Add ("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"); // } //element completion if (currentChar == '<' && tracker.Engine.CurrentState is XmlRootState || (tracker.Engine.CurrentState is XmlNameState && forced)) { var list = await GetElementCompletions (token); AddCloseTag (list, Tracker.Engine.Nodes); return list.Count > 0 ? list : null; } if (forced && Tracker.Engine.CurrentState is XmlRootState) { var list = new CompletionDataList (); MonoDevelop.Ide.CodeTemplates.CodeTemplateService.AddCompletionDataForFileName (DocumentContext.Name, list); return list.Count > 0? list : null; } return null; }
public OPCSigner(X509Certificate2 certificate, LoggingService log) { Certificate = certificate; _log = log; }
public CommitDialog(ChangeSet changeSet) { Build(); store = new ListStore(typeof(Xwt.Drawing.Image), typeof(string), typeof(string), typeof(bool), typeof(object)); fileList.Model = store; fileList.SearchColumn = -1; // disable the interactive search this.changeSet = changeSet; oldMessage = changeSet.GlobalComment; CellRendererText crt = new CellRendererText(); var crp = new CellRendererImage(); TreeViewColumn colStatus = new TreeViewColumn(); colStatus.Title = GettextCatalog.GetString("Status"); colStatus.PackStart(crp, false); colStatus.PackStart(crt, true); colStatus.Spacing = 2; colStatus.AddAttribute(crp, "image", 0); colStatus.AddAttribute(crt, "text", 1); CellRendererToggle cellToggle = new CellRendererToggle(); cellToggle.Toggled += new ToggledHandler(OnCommitToggledHandler); TreeViewColumn colCommit = new TreeViewColumn("", cellToggle, "active", 3); TreeViewColumn colFile = new TreeViewColumn(GettextCatalog.GetString("File"), new CellRendererText(), "text", 2); fileList.AppendColumn(colCommit); fileList.AppendColumn(colStatus); fileList.AppendColumn(colFile); colCommit.Visible = false; object[] exts = AddinManager.GetExtensionObjects("/MonoDevelop/VersionControl/CommitDialogExtensions", false); bool separatorRequired = false; foreach (object ob in exts) { CommitDialogExtension ext = ob as CommitDialogExtension; if (ext == null) { LoggingService.LogError("Commit extension type " + ob.GetType() + " must be a subclass of CommitDialogExtension"); continue; } if (ext.Initialize(changeSet)) { ext.CommitDialog = this; var newTitle = ext.FormatDialogTitle(changeSet, Title); if (newTitle != null) { Title = newTitle; } ext.CommitMessageTextViewHook(textview); if (separatorRequired) { HSeparator sep = new HSeparator(); sep.Show(); vboxExtensions.PackEnd(sep, false, false, 0); } vboxExtensions.PackEnd(ext, false, false, 0); extensions.Add(ext); ext.AllowCommitChanged += HandleAllowCommitChanged; separatorRequired = true; } else { ext.Destroy(); } } HandleAllowCommitChanged(null, null); LoadChangeset(changeSet.Items); if (string.IsNullOrEmpty(changeSet.GlobalComment)) { AuthorInformation aInfo; CommitMessageFormat fmt = VersionControlService.GetCommitMessageFormat(changeSet, out aInfo); Message = changeSet.GenerateGlobalComment(fmt, aInfo); } else { Message = changeSet.GlobalComment; } textview.Buffer.Changed += OnTextChanged; responseSensitive = !string.IsNullOrEmpty(Message); // Focus the text view and move the insert point to the beginning. Makes it easier to insert // a comment header. textview.Buffer.MoveMark(textview.Buffer.InsertMark, textview.Buffer.StartIter); textview.Buffer.MoveMark(textview.Buffer.SelectionBound, textview.Buffer.StartIter); textview.GrabFocus(); textview.Buffer.MarkSet += OnMarkSet; SetResponseSensitive(ResponseType.Ok, responseSensitive); VersionControlService.FileStatusChanged += OnFileStatusChanged; }
int Run (MonoDevelopOptions options) { LoggingService.LogInfo ("Starting {0} {1}", BrandingService.ApplicationLongName, IdeVersionInfo.MonoDevelopVersion); LoggingService.LogInfo ("Build Information{0}{1}", Environment.NewLine, SystemInformation.GetBuildInformation ()); LoggingService.LogInfo ("Running on {0}", RuntimeVersionInfo.GetRuntimeInfo ()); //ensure native libs initialized before we hit anything that p/invokes Platform.Initialize (); sectionTimings ["PlatformInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); GettextCatalog.Initialize (); sectionTimings ["GettextInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); LoggingService.LogInfo ("Operating System: {0}", SystemInformation.GetOperatingSystemDescription ()); if (!Platform.IsWindows) { // The assembly resolver for MSBuild 15 assemblies needs to be defined early on. // Whilst Runtime.Initialize loads the MSBuild 15 assemblies from Mono this seems // to be too late to prevent the MEF composition and the static registrar from // failing to load the MonoDevelop.Ide assembly which now uses MSBuild 15 assemblies. ResolveMSBuildAssemblies (); } Counters.Initialization.BeginTiming (); if (options.PerfLog) { string logFile = Path.Combine (Environment.CurrentDirectory, "monodevelop.perf-log"); LoggingService.LogInfo ("Logging instrumentation service data to file: " + logFile); InstrumentationService.StartAutoSave (logFile, 1000); } Counters.Initialization.Trace ("Initializing GTK"); if (Platform.IsWindows && !CheckWindowsGtk ()) return 1; SetupExceptionManager (); // explicit GLib type system initialization for GLib < 2.36 before any other type system access GLib.GType.Init (); IdeApp.Customizer = options.IdeCustomizer ?? new IdeCustomizer (); try { IdeApp.Customizer.Initialize (); } catch (UnauthorizedAccessException ua) { LoggingService.LogError ("Unauthorized access: " + ua.Message); return 1; } try { GLibLogging.Enabled = true; } catch (Exception ex) { LoggingService.LogError ("Error initialising GLib logging.", ex); } var args = options.RemainingArgs.ToArray (); IdeTheme.InitializeGtk (BrandingService.ApplicationName, ref args); sectionTimings["GtkInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); LoggingService.LogInfo ("Using GTK+ {0}", IdeVersionInfo.GetGtkVersion ()); // XWT initialization FilePath p = typeof(IdeStartup).Assembly.Location; Runtime.LoadAssemblyFrom (p.ParentDirectory.Combine("Xwt.Gtk.dll")); Xwt.Application.InitializeAsGuest (Xwt.ToolkitType.Gtk); Xwt.Toolkit.CurrentEngine.RegisterBackend<IExtendedTitleBarWindowBackend,GtkExtendedTitleBarWindowBackend> (); Xwt.Toolkit.CurrentEngine.RegisterBackend<IExtendedTitleBarDialogBackend,GtkExtendedTitleBarDialogBackend> (); IdeTheme.SetupXwtTheme (); sectionTimings["XwtInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); //default to Windows IME on Windows if (Platform.IsWindows && GtkWorkarounds.GtkMinorVersion >= 16) { var settings = Gtk.Settings.Default; var val = GtkWorkarounds.GetProperty (settings, "gtk-im-module"); if (string.IsNullOrEmpty (val.Val as string)) GtkWorkarounds.SetProperty (settings, "gtk-im-module", new GLib.Value ("ime")); } string socket_filename = null; EndPoint ep = null; DispatchService.Initialize (); // Set a synchronization context for the main gtk thread SynchronizationContext.SetSynchronizationContext (DispatchService.SynchronizationContext); Runtime.MainSynchronizationContext = SynchronizationContext.Current; sectionTimings["DispatchInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); // Initialize Roslyn's synchronization context RoslynServices.RoslynService.Initialize (); sectionTimings["RoslynInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); AddinManager.AddinLoadError += OnAddinError; var startupInfo = new StartupInfo (args); // If a combine was specified, force --newwindow. if (!options.NewWindow && startupInfo.HasFiles) { Counters.Initialization.Trace ("Pre-Initializing Runtime to load files in existing window"); Runtime.Initialize (true); foreach (var file in startupInfo.RequestedFileList) { if (MonoDevelop.Projects.Services.ProjectService.IsWorkspaceItemFile (file.FileName)) { options.NewWindow = true; break; } } } Counters.Initialization.Trace ("Initializing Runtime"); Runtime.Initialize (true); sectionTimings ["RuntimeInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); bool restartRequested = PropertyService.Get ("MonoDevelop.Core.RestartRequested", false); startupInfo.Restarted = restartRequested; PropertyService.Set ("MonoDevelop.Core.RestartRequested", false); IdeApp.Customizer.OnCoreInitialized (); Counters.Initialization.Trace ("Initializing theme"); IdeTheme.SetupGtkTheme (); sectionTimings["ThemeInitialized"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); ProgressMonitor monitor = new MonoDevelop.Core.ProgressMonitoring.ConsoleProgressMonitor (); monitor.BeginTask (GettextCatalog.GetString ("Starting {0}", BrandingService.ApplicationName), 2); //make sure that the platform service is initialised so that the Mac platform can subscribe to open-document events Counters.Initialization.Trace ("Initializing Platform Service"); DesktopService.Initialize (); sectionTimings["PlatformInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); monitor.Step (1); if (options.IpcTcp) { listen_socket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); ep = new IPEndPoint (IPAddress.Loopback, ipcBasePort + HashSdbmBounded (Environment.UserName)); } else { socket_filename = "/tmp/md-" + Environment.GetEnvironmentVariable ("USER") + "-socket"; listen_socket = new Socket (AddressFamily.Unix, SocketType.Stream, ProtocolType.IP); ep = new UnixEndPoint (socket_filename); } // If not opening a combine, connect to existing monodevelop and pass filename(s) and exit if (!options.NewWindow && startupInfo.HasFiles) { try { StringBuilder builder = new StringBuilder (); foreach (var file in startupInfo.RequestedFileList) { builder.AppendFormat ("{0};{1};{2}\n", file.FileName, file.Line, file.Column); } listen_socket.Connect (ep); listen_socket.Send (Encoding.UTF8.GetBytes (builder.ToString ())); return 0; } catch { // Reset the socket if (null != socket_filename && File.Exists (socket_filename)) File.Delete (socket_filename); } } Counters.Initialization.Trace ("Checking System"); CheckFileWatcher (); sectionTimings["FileWatcherInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); Exception error = null; int reportedFailures = 0; try { Counters.Initialization.Trace ("Loading Icons"); //force initialisation before the workbench so that it can register stock icons for GTK before they get requested ImageService.Initialize (); sectionTimings ["ImageInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); // If we display an error dialog before the main workbench window on OS X then a second application menu is created // which is then replaced with a second empty Apple menu. // XBC #33699 Counters.Initialization.Trace ("Initializing IdeApp"); hideWelcomePage = startupInfo.HasFiles; IdeApp.Initialize (monitor, hideWelcomePage); sectionTimings ["AppInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); if (errorsList.Count > 0) { using (AddinLoadErrorDialog dlg = new AddinLoadErrorDialog (errorsList.ToArray (), false)) { if (!dlg.Run ()) return 1; } reportedFailures = errorsList.Count; } if (!CheckSCPlugin ()) return 1; // Load requested files Counters.Initialization.Trace ("Opening Files"); // load previous combine RecentFile openedProject = null; if (IdeApp.Preferences.LoadPrevSolutionOnStartup && !startupInfo.HasSolutionFile && !IdeApp.Workspace.WorkspaceItemIsOpening && !IdeApp.Workspace.IsOpen) { openedProject = DesktopService.RecentFiles.MostRecentlyUsedProject; if (openedProject != null) { var metadata = GetOpenWorkspaceOnStartupMetadata (); IdeApp.Workspace.OpenWorkspaceItem (openedProject.FileName, true, true, metadata).ContinueWith (t => IdeApp.OpenFiles (startupInfo.RequestedFileList, metadata), TaskScheduler.FromCurrentSynchronizationContext ()); startupInfo.OpenedRecentProject = true; } } if (openedProject == null) { IdeApp.OpenFiles (startupInfo.RequestedFileList, GetOpenWorkspaceOnStartupMetadata ()); startupInfo.OpenedFiles = startupInfo.HasFiles; } monitor.Step (1); } catch (Exception e) { error = e; } finally { monitor.Dispose (); } if (error != null) { string message = BrandingService.BrandApplicationName (GettextCatalog.GetString ("MonoDevelop failed to start")); message = message + "\n\n" + error.Message; MessageService.ShowFatalError (message, null, error); return 1; } if (errorsList.Count > reportedFailures) { using (AddinLoadErrorDialog dlg = new AddinLoadErrorDialog (errorsList.ToArray (), true)) dlg.Run (); } errorsList = null; AddinManager.AddinLoadError -= OnAddinError; sectionTimings["BasicInitializationCompleted"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); // FIXME: we should probably track the last 'selected' one // and do this more cleanly try { listen_socket.Bind (ep); listen_socket.Listen (5); listen_socket.BeginAccept (new AsyncCallback (ListenCallback), listen_socket); } catch { // Socket already in use } sectionTimings["SocketInitialization"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); initialized = true; MessageService.RootWindow = IdeApp.Workbench.RootWindow; Xwt.MessageDialog.RootWindow = Xwt.Toolkit.CurrentEngine.WrapWindow (IdeApp.Workbench.RootWindow); sectionTimings["WindowOpened"] = startupSectionTimer.ElapsedMilliseconds; startupSectionTimer.Restart (); Thread.CurrentThread.Name = "GUI Thread"; Counters.Initialization.Trace ("Running IdeApp"); Counters.Initialization.EndTiming (); AddinManager.AddExtensionNodeHandler("/MonoDevelop/Ide/InitCompleteHandlers", OnExtensionChanged); StartLockupTracker (); // This call is important so the current event loop is run before we run the main loop. // On Mac, the OpenDocuments event gets handled here, so we need to get the timeout // it queues before the OnIdle event so we can start opening a solution before // we show the main window. DispatchService.RunPendingEvents (); sectionTimings ["PumpEventLoop"] = startupSectionTimer.ElapsedMilliseconds; startupTimer.Stop (); startupSectionTimer.Stop (); // Need to start this timer because we don't know yet if we've been asked to open a solution from the file manager. timeToCodeTimer.Start (); ttcMetadata = new TimeToCodeMetadata { StartupTime = startupTimer.ElapsedMilliseconds }; // Start this timer to limit the time to decide if the app was opened by a file manager IdeApp.StartFMOpenTimer (FMOpenTimerExpired); IdeApp.Workspace.FirstWorkspaceItemOpened += CompleteSolutionTimeToCode; IdeApp.Workbench.DocumentOpened += CompleteFileTimeToCode; CreateStartupMetadata (startupInfo, sectionTimings); GLib.Idle.Add (OnIdle); IdeApp.Run (); IdeApp.Customizer.OnIdeShutdown (); // unloading services if (null != socket_filename) File.Delete (socket_filename); lockupCheckRunning = false; Runtime.Shutdown (); IdeApp.Customizer.OnCoreShutdown (); InstrumentationService.Stop (); MonoDevelop.Components.GtkWorkarounds.Terminate (); return 0; }
private async void GetArtistImage(CancellationToken token) { var audio = AudioService.CurrentAudio; if (audio == null) { return; } if (audio.Artist == _lastArtist) { return; } _lastArtist = audio.Artist; string imageType = "big"; try { var cachedImage = await CacheService.GetCachedImage("artists/" + CacheService.GetSafeFileName(audio.Artist + "_" + imageType + ".jpg")); if (cachedImage != null) { var lastUpdateTime = FileStorage.GetFileUpdateTime("artists/" + CacheService.GetSafeFileName(audio.Artist + "_" + imageType + ".jpg")); if ((DateTime.Now - lastUpdateTime).TotalDays < 14) { //if image was downloaded less than 2 weeks ago, show it, else download newer ArtistImage = cachedImage; return; } } if (Settings.Instance.DownloadArtistArt) { var imageUri = await DataService.GetArtistImage(audio.Artist, true); if (imageUri != null) { if (token.IsCancellationRequested) { return; } cachedImage = await CacheService.CacheImage(imageUri.OriginalString, "artists/" + CacheService.GetSafeFileName(audio.Artist + "_" + imageType + ".jpg")); if (token.IsCancellationRequested) { return; } ArtistImage = cachedImage; return; } } ArtistImage = null; } catch (Exception ex) { LoggingService.Log(ex); } }
public GcLogCmdlet() { Service = new LoggingService(GetBaseClientServiceInitializer()); }
internal SvnClientException(SvnException ex) : base(ex.Message, ex) { this.errorCode = ex.SvnErrorCode; LoggingService.Debug(ex); }
internal UnitTestResult RunUnitTest(UnitTest test, string suiteName, string pathName, string testName, TestContext testContext) { var runnerExe = GetCustomConsoleRunnerCommand(); if (runnerExe != null) { return(RunWithConsoleRunner(runnerExe, test, suiteName, pathName, testName, testContext)); } ExternalTestRunner runner = (ExternalTestRunner)Runtime.ProcessService.CreateExternalProcessObject(typeof(ExternalTestRunner), testContext.ExecutionContext, UserAssemblyPaths); LocalTestMonitor localMonitor = new LocalTestMonitor(testContext, test, suiteName, testName != null); ITestFilter filter = null; if (test != null) { if (test is UnitTestGroup) { filter = new TestNameFilter(CollectTests((UnitTestGroup)test)); } else { filter = new TestNameFilter(test.TestId); } } else { NUnitCategoryOptions categoryOptions = (NUnitCategoryOptions)test.GetOptions(typeof(NUnitCategoryOptions)); if (categoryOptions.EnableFilter && categoryOptions.Categories.Count > 0) { string[] cats = new string [categoryOptions.Categories.Count]; categoryOptions.Categories.CopyTo(cats, 0); filter = new CategoryFilter(cats); if (categoryOptions.Exclude) { filter = new NotFilter(filter); } } } RunData rd = new RunData(); rd.Runner = runner; rd.Test = this; rd.LocalMonitor = localMonitor; testContext.Monitor.CancelRequested += new TestHandler(rd.Cancel); UnitTestResult result; try { if (string.IsNullOrEmpty(AssemblyPath)) { string msg = GettextCatalog.GetString("Could not get a valid path to the assembly. There may be a conflict in the project configurations."); throw new Exception(msg); } System.Runtime.Remoting.RemotingServices.Marshal(localMonitor, null, typeof(IRemoteEventListener)); string testRunnerAssembly, testRunnerType; GetCustomTestRunner(out testRunnerAssembly, out testRunnerType); result = runner.Run(localMonitor, filter, AssemblyPath, "", new List <string> (SupportAssemblies), testRunnerType, testRunnerAssembly); if (testName != null) { result = localMonitor.SingleTestResult; } } catch (Exception ex) { if (!localMonitor.Canceled) { LoggingService.LogError(ex.ToString()); if (localMonitor.RunningTest != null) { RuntimeErrorCleanup(testContext, localMonitor.RunningTest, ex); } else { testContext.Monitor.ReportRuntimeError(null, ex); throw; } result = UnitTestResult.CreateFailure(ex); } else { result = UnitTestResult.CreateFailure(GettextCatalog.GetString("Canceled"), null); } } finally { testContext.Monitor.CancelRequested -= new TestHandler(rd.Cancel); runner.Dispose(); System.Runtime.Remoting.RemotingServices.Disconnect(localMonitor); } return(result); }
public WidgetService(IAtomicCmsDataRepository dataContext, LoggingService log) { _dataContext = dataContext; _log = log; }
protected virtual ICompletionDataList HandleCodeCompletion( CodeCompletionContext completionContext, bool forced, ref int triggerWordLength) { IEditableTextBuffer buf = this.EditableBuffer; // completionChar may be a space even if the current char isn't, when ctrl-space is fired t DomLocation currentLocation = new DomLocation(completionContext.TriggerLine, completionContext.TriggerLineOffset); char currentChar = completionContext.TriggerOffset < 1? ' ' : buf.GetCharAt(completionContext.TriggerOffset - 1); char previousChar = completionContext.TriggerOffset < 2? ' ' : buf.GetCharAt(completionContext.TriggerOffset - 2); LoggingService.LogDebug("Attempting completion for state '{0}'x{1}, previousChar='{2}'," + " currentChar='{3}', forced='{4}'", tracker.Engine.CurrentState, tracker.Engine.CurrentStateLength, previousChar, currentChar, forced); //closing tag completion if (tracker.Engine.CurrentState is XmlFreeState && currentChar == '>') { //get name of current node in document that's being ended XElement el = tracker.Engine.Nodes.Peek() as XElement; if (el != null && el.Region.End >= currentLocation && !el.IsClosed && el.IsNamed) { string tag = String.Concat("</", el.Name.FullName, ">"); if (XmlEditorOptions.AutoCompleteElements) { buf.BeginAtomicUndo(); buf.InsertText(buf.CursorPosition, tag); buf.CursorPosition -= tag.Length; buf.EndAtomicUndo(); return(null); } else { CompletionDataList cp = new CompletionDataList(); cp.Add(new XmlTagCompletionData(tag, 0, true)); return(cp); } } return(null); } // Auto insert '>' when '/' is typed inside tag state (for quick tag closing) //FIXME: avoid doing this when the next non-whitespace char is ">" or ignore the next ">" typed if (XmlEditorOptions.AutoInsertFragments && tracker.Engine.CurrentState is XmlTagState && currentChar == '/') { buf.BeginAtomicUndo(); buf.InsertText(buf.CursorPosition, ">"); buf.EndAtomicUndo(); return(null); } //element completion if (currentChar == '<' && tracker.Engine.CurrentState is XmlFreeState) { CompletionDataList list = new CompletionDataList(); GetElementCompletions(list); AddCloseTag(list, Tracker.Engine.Nodes); return(list.Count > 0? list : null); } //entity completion if (currentChar == '&' && (tracker.Engine.CurrentState is XmlFreeState || tracker.Engine.CurrentState is XmlAttributeValueState)) { CompletionDataList list = new CompletionDataList(); //TODO: need to tweak semicolon insertion list.Add("apos").Description = "'"; list.Add("quot").Description = "\""; list.Add("lt").Description = "<"; list.Add("gt").Description = ">"; list.Add("amp").Description = "&"; //not sure about these "completions". they're more like //shortcuts than completions but they're pretty useful list.Add("'").CompletionText = "apos;"; list.Add("\"").CompletionText = "quot;"; list.Add("<").CompletionText = "lt;"; list.Add(">").CompletionText = "gt;"; list.Add("&").CompletionText = "amp;"; GetEntityCompletions(list); return(list); } //doctype completion if (tracker.Engine.CurrentState is XmlDocTypeState) { if (tracker.Engine.CurrentStateLength == 1) { CompletionDataList list = GetDocTypeCompletions(); if (list != null && list.Count > 0) { return(list); } } return(null); } //attribute name completion if ((forced && Tracker.Engine.Nodes.Peek() is IAttributedXObject && !tracker.Engine.Nodes.Peek().IsEnded) || (Tracker.Engine.CurrentState is XmlNameState && Tracker.Engine.CurrentState.Parent is XmlAttributeState && Tracker.Engine.CurrentStateLength == 1) ) { IAttributedXObject attributedOb = (Tracker.Engine.Nodes.Peek() as IAttributedXObject) ?? Tracker.Engine.Nodes.Peek(1) as IAttributedXObject; if (attributedOb == null) { return(null); } //attributes if (attributedOb.Name.IsValid && (forced || (char.IsWhiteSpace(previousChar) && char.IsLetter(currentChar)))) { if (!forced) { triggerWordLength = 1; } var existingAtts = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase); foreach (XAttribute att in attributedOb.Attributes) { existingAtts [att.Name.FullName] = att.Value ?? string.Empty; } return(GetAttributeCompletions(attributedOb, existingAtts)); } } //attribute value completion //determine whether to trigger completion within attribute values quotes if ((Tracker.Engine.CurrentState is XmlDoubleQuotedAttributeValueState || Tracker.Engine.CurrentState is XmlSingleQuotedAttributeValueState) //trigger on the opening quote && (Tracker.Engine.CurrentStateLength == 0 //or trigger on first letter of value, if unforced || (!forced && Tracker.Engine.CurrentStateLength == 1)) ) { XAttribute att = (XAttribute)Tracker.Engine.Nodes.Peek(); if (att.IsNamed) { IAttributedXObject attributedOb = Tracker.Engine.Nodes.Peek(1) as IAttributedXObject; if (attributedOb == null) { return(null); } char next = ' '; if (completionContext.TriggerOffset < buf.Length) { next = buf.GetCharAt(completionContext.TriggerOffset); } char compareChar = (Tracker.Engine.CurrentStateLength == 0)? currentChar : previousChar; if ((compareChar == '"' || compareChar == '\'') && (next == compareChar || char.IsWhiteSpace(next)) ) { //if triggered by first letter of value, grab that letter if (Tracker.Engine.CurrentStateLength == 1) { triggerWordLength = 1; } return(GetAttributeValueCompletions(attributedOb, att)); } } } // if (Tracker.Engine.CurrentState is XmlFreeState) { // if (line < 3) { // cp.Add ("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"); // } if (forced && Tracker.Engine.CurrentState is XmlFreeState) { CompletionDataList list = new CompletionDataList(); MonoDevelop.Ide.CodeTemplates.CodeTemplateService.AddCompletionDataForFileName(Document.Name, list); return(list.Count > 0? list : null); } return(null); }
public ToolsController(PageService pageService, SettingService settingService, LoggingService log) { this.pageService = pageService; this.settingService = settingService; this.log = log; }
public static void ShowMessage(string message, string caption) { LoggingService.Info(message); ServiceManager.MessageService.ShowMessage(message, caption); }
/// <summary> /// Gets all possible monitored resource descriptors. /// </summary> private static List<MonitoredResourceDescriptor> GetResourceDescriptors() { List<MonitoredResourceDescriptor> monitoredResourceDescriptors = new List<MonitoredResourceDescriptor>(); LoggingService service = new LoggingService(GetBaseClientServiceInitializer()); MonitoredResourceDescriptorsResource.ListRequest request = service.MonitoredResourceDescriptors.List(); do { ListMonitoredResourceDescriptorsResponse response = request.Execute(); if (response.ResourceDescriptors != null) { monitoredResourceDescriptors.AddRange(response.ResourceDescriptors); } request.PageToken = response.NextPageToken; } while (request.PageToken != null); return monitoredResourceDescriptors; }
/// <summary> /// Shows a warning message. /// </summary> public static void ShowWarning(string message) { LoggingService.Warn(message); ServiceManager.MessageService.ShowWarning(message); }
void GlobalSetup() { //FIXME: should we remove these when finalizing? try { ApplicationEvents.Quit += delegate(object sender, ApplicationQuitEventArgs e) { // We can only attempt to quit safely if all windows are GTK windows and not modal if (!IsModalDialogRunning()) { e.UserCancelled = !IdeApp.Exit(); e.Handled = true; return; } // When a modal dialog is running, things are much harder. We can't just shut down MD behind the // dialog, and aborting the dialog may not be appropriate. // // There's NSTerminateLater but I'm not sure how to access it from carbon, maybe // we need to swizzle methods into the app's NSApplicationDelegate. // Also, it stops the main CFRunLoop and enters a special runloop mode, not sure how that would // interact with GTK+. // For now, just bounce NSApplication.SharedApplication.RequestUserAttention(NSRequestUserAttentionType.CriticalRequest); // and abort the quit. e.UserCancelled = true; e.Handled = true; }; ApplicationEvents.Reopen += delegate(object sender, ApplicationEventArgs e) { if (IdeApp.Workbench != null && IdeApp.Workbench.RootWindow != null) { IdeApp.Workbench.RootWindow.Deiconify(); IdeApp.Workbench.RootWindow.Visible = true; IdeApp.Workbench.RootWindow.Present(); e.Handled = true; } }; ApplicationEvents.OpenDocuments += delegate(object sender, ApplicationDocumentEventArgs e) { //OpenFiles may pump the mainloop, but can't do that from an AppleEvent, so use a brief timeout GLib.Timeout.Add(10, delegate { IdeApp.OpenFiles(e.Documents.Select( doc => new FileOpenInformation(doc.Key, null, doc.Value, 1, OpenDocumentOptions.DefaultInternal)) ); return(false); }); e.Handled = true; }; ApplicationEvents.OpenUrls += delegate(object sender, ApplicationUrlEventArgs e) { GLib.Timeout.Add(10, delegate { // Open files via the monodevelop:// URI scheme, compatible with the // common TextMate scheme: http://blog.macromates.com/2007/the-textmate-url-scheme/ IdeApp.OpenFiles(e.Urls.Select(url => { try { var uri = new Uri(url); if (uri.Host != "open") { return(null); } var qs = System.Web.HttpUtility.ParseQueryString(uri.Query); var fileUri = new Uri(qs ["file"]); int line, column; if (!Int32.TryParse(qs ["line"], out line)) { line = 1; } if (!Int32.TryParse(qs ["column"], out column)) { column = 1; } return(new FileOpenInformation(Uri.UnescapeDataString(fileUri.AbsolutePath), null, line, column, OpenDocumentOptions.DefaultInternal)); } catch (Exception ex) { LoggingService.LogError("Invalid TextMate URI: " + url, ex); return(null); } }).Where(foi => foi != null)); return(false); }); }; //if not running inside an app bundle (at dev time), need to do some additional setup if (NSBundle.MainBundle.InfoDictionary ["CFBundleIdentifier"] == null) { SetupWithoutBundle(); } else { SetupDockIcon(); } } catch (Exception ex) { LoggingService.LogError("Could not install app event handlers", ex); setupFail = true; } }
public async Task RefreshHistoryDataFromCache(string grouping) { try { //await Task.Run(() => //{ //await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () => //{ LoggingService.LogInformation("RefreshDataFromCache'", "YouTubeService.RefreshDataFromCache"); var foundPlaying = StandardFeedResults.Where(x => !string.IsNullOrEmpty(x.UIStateFull)); if (foundPlaying != null & foundPlaying.Count() > 0) { //StandardFeedResults.ToList().RemoveAll(x => x != foundPlaying.First()); var tempUIDs = StandardFeedResults.Where(x => string.IsNullOrEmpty(x.UIStateFull)).Select(x => x.Uid).ToArray(); string foundUID = foundPlaying.First().Uid; for (int i = 0; i < tempUIDs.Count(); i++) { //if (tempUIDs[i] != foundUID) StandardFeedResults.Remove(StandardFeedResults.Where(x => x.Uid == tempUIDs[i] && string.IsNullOrEmpty(x.UIStateFull)).First()); } } else { StandardFeedResults.Clear(); } var found = AppDatabase.Current.RetrieveYoutubeHistoryItemByGrouping(grouping); if (found != null && found.Count > 0) { //StandardFeedResults.ToList().RemoveAll(x => x._Grouping == grouping); found.Reverse(); foreach (var item in found) { var ytdi = new YoutubeDataItem(item.Uid, item.Title, item.Subtitle, item.ImagePath, item.Description, item.VideoId, null); ytdi._Grouping = grouping; //if (StandardFeedResults.Count() == 0) StandardFeedResults.Add(ytdi); //else // StandardFeedResults.Insert(0, ytdi); } return; } //}); //}); } catch (Exception ex) { AlertService.LogAlertMessage("Error retrieving History from Cache", ex.Message); } return; }