private ContentResult RejectResult(string reason) { string xmlString = @"<Response><Reject /></Response>"; Logging.AddErrorLog($"{nameof(RejectResult)}: {reason} {xmlString}"); return(this.Content(xmlString, "text/xml")); }
public static List <BackupProfile> GetAll() { List <BackupProfile> items = new List <BackupProfile>(); string backupProfilesFolder = Settings.Current.BackupProfilesFolder; CraftSynth.BuildingBlocks.IO.FileSystem.CreateFolderIfItDoesNotExist(backupProfilesFolder); string[] fileNames = Directory.GetFiles(backupProfilesFolder, "*.bp"); foreach (string fileName in fileNames) { try { string filePath = Path.Combine(backupProfilesFolder, fileName); string name = Path.GetFileNameWithoutExtension(fileName).ToLower(); BackupProfile backupProfile = new BackupProfile(); backupProfile.Name = name; items.Add(backupProfile); } catch (Exception exception) { Logging.AddErrorLog("ExtensionMacro: Adding of backup profile '" + fileName + "' failed : " + exception.Message); Common.Logging.AddExceptionLog(exception); } } return(items); }
public static void DumpHeaders(string usedRequestUrl, Dictionary <string, string> dict, string signature, bool Error = true) { StringBuilder sb = new StringBuilder(); sb.Append($"UsedRequestUrl={usedRequestUrl}\r\n"); sb.Append($"Signature={signature}\r\n"); string requestUrl = Manager.CurrentRequestUrl; sb.Append($"RequestUrl={requestUrl}\r\n"); HttpRequest request = Manager.CurrentRequest; foreach (string key in request.Headers.Keys) { sb.Append($"{key}={request.Headers[key]}\r\n"); } foreach (string key in dict.Keys) { sb.Append($"dict[{key}]={dict[key]}\r\n"); } if (Error) { Logging.AddErrorLog(sb.ToString()); } else { Logging.AddLog(sb.ToString()); } }
public static List <Macro> GetNamesAndFilePaths() { List <Macro> items = new List <Macro>(); string macrosFolder = Settings.Current.MacrosDataFolder; CraftSynth.BuildingBlocks.IO.FileSystem.CreateFolderIfItDoesNotExist(macrosFolder); string[] fileNames = Directory.GetFiles(macrosFolder, "*.mcr"); foreach (string fileName in fileNames) { try { string filePath = Path.Combine(macrosFolder, fileName); string name = Path.GetFileNameWithoutExtension(fileName).ToLower(); Macro macro = new Macro(); macro.name = name; macro.filePath = filePath; items.Add(macro); } catch (Exception exception) { Logging.AddErrorLog("ExtensionMacro: Adding of macro '" + fileName + "' failed : " + exception.Message); Common.Logging.AddExceptionLog(exception); } } return(items); }
private async Task SearchPageAsync(SearchWords searchWords, PageDefinition page) { if (!searchWords.WantPage(page)) { return; } if (await searchWords.SetUrlAsync(page.Url, page.PageSecurity, page.Title, page.Description, page.Created, page.Updated, page.IsAuthorized_View_Anonymous(), page.IsAuthorized_View_AnyUser())) { searchWords.AddKeywords(page.Keywords); foreach (var m in page.ModuleDefinitions) { Guid modGuid = m.ModuleGuid; ModuleDefinition mod = null; try { mod = await ModuleDefinition.LoadAsync(m.ModuleGuid); } catch (Exception ex) { Logging.AddErrorLog("An error occurred retrieving module {0} in page {1}", m.ModuleGuid, page.Url, ex); } if (mod != null) { SearchModule(searchWords, mod); } } await searchWords.SaveAsync(); } }
//[STAThreadAttribute] public static void Main() { Logging.AddActionLog("Starting Enso+ ..."); //IsFirstRun = !File.Exists(Settings.FilePath); //Not working //Application.ThreadException += new ThreadExceptionEventHandler(BuildingBlocks.Exceptions.EnterpriseLibrary.ExceptionHandler.Application_ThreadException); Application.ThreadException += Application_ThreadException; try { if (Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName).Count() >= 2) { MessageBox.Show("Enso+ is already running."); } else { //Logging.AddActionLog("Starting EnsoPlus.Guard in not running already ..."); string ensoPlusGuardExeFilePath = Path.Combine(CraftSynth.BuildingBlocks.Common.Misc.ApplicationRootFolderPath, "EnsoPlus.Guard.exe"); CraftSynth.BuildingBlocks.WindowsNT.Misc.OpenFile(ensoPlusGuardExeFilePath); Helper.PreDeleteLogs(); if (Settings.Current.firstRun || !File.Exists(Path.Combine(Common.Helper.GetEnsoPlusWorkingFolder(), "Version.txt"))) { Common.HandlerForPreviousVersions.OfferImportingOfSettingsFromPreviousVersion(); } if (Settings.Current.firstRun) { Settings.Current.firstRun = false; Settings.Current.Save(); } extensionPlus = new EnsoPlus(); var mergedCommands = extensionPlus.GetMergedCommands(); cornerLauncher = new CornerLauncher(mergedCommands, OnClose); // extensionPlus.OnCommand( mergedCommands[mergedCommands.Keys.Single(k=>k=="open")].sourceCommands[0], string.Empty); ParameterInput.Init(); Logging.AddActionLog(string.Format("Started Enso+ {0}", CraftSynth.BuildingBlocks.Common.Misc.version ?? string.Empty)); MessagesHandler.Display("Welcome to Enso+"); var f = new FormMain(); f.Visible = false; f.Width = 0; f.Height = 0; Application.Run(f); } } catch (Exception exception) { Logging.AddErrorLog("Server: Starting failed: " + exception.Message); Common.Logging.AddExceptionLog(exception); } }
public static void SaveAllTabs(bool saveInOneFile, Extension.IEnsoService service, string caption, string shortcutsFolder, string commandProviderNameForLog) { string clipboardText = CraftSynth.BuildingBlocks.IO.Clipboard.GetTextFromClipboard(); clipboardText = clipboardText.Trim(); if (string.IsNullOrEmpty(clipboardText)) { MessagesHandler.Display("Error: Clipboard empty.", saveAllTabsUserManual); } else { Entities.WorkItems.Shortcuts shortcuts = null; try { shortcuts = new Entities.WorkItems.Shortcuts(caption, clipboardText); if (shortcuts.shortcuts.Count == 0) { throw new ApplicationException("No urls in clipboard."); } } catch (Exception) { MessagesHandler.Display("Error: Invalid text format in clipboard.", saveAllTabsUserManual); Logging.AddErrorLog(commandProviderNameForLog + ": Error: Invalid text format in clipboard"); } if (shortcuts != null && shortcuts.shortcuts.Count > 0) { if (string.IsNullOrEmpty(shortcutsFolder)) { shortcutsFolder = Settings.Current.EnsoLearnAsOpenCommandsFolder; } CraftSynth.BuildingBlocks.IO.FileSystem.CreateFolderIfItDoesNotExist(shortcutsFolder); if (saveInOneFile) { shortcuts.Save(shortcutsFolder); SuggestionsCache.DropCache(typeof(WorkItemsProviders.Shortcuts.ShortcutsLists)); Logging.AddActionLog(string.Format(commandProviderNameForLog + ": {0} tabs saved in '{1}'.", shortcuts.shortcuts.Count, Path.Combine(shortcutsFolder, caption))); MessagesHandler.Display(string.Format("{0} tabs saved in one shortcut {1}.", shortcuts.shortcuts.Count, caption)); } else { shortcuts.SaveAsSeparateShortcuts(shortcutsFolder); Logging.AddActionLog(string.Format(commandProviderNameForLog + ": {0} tabs saved as separate files in '{1}'.", shortcuts.shortcuts.Count, shortcutsFolder)); MessagesHandler.Display(string.Format("{0} shortcuts saved in category {1}.", shortcuts.shortcuts.Count, caption)); } } } }
private async Task <ExtUserInfo> GetUserInfo(LoginConfigData config) { ExtUserInfo info = new ExtUserInfo(); SignInManager <UserDefinition> _signinManager = (SignInManager <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(SignInManager <UserDefinition>)); ExternalLoginInfo loginInfo = await _signinManager.GetExternalLoginInfoAsync(); if (loginInfo == null) { Logging.AddErrorLog("AuthenticationManager.GetExternalLoginInfoAsync() returned null"); throw new Error(this.__ResStr("noExtLogin", "No external login has been processed")); } info.LoginInfo = loginInfo; info.Email = loginInfo.Principal.FindFirstValue(ClaimTypes.Email); info.Name = loginInfo.Principal.FindFirstValue(ClaimTypes.Name); info.LoginProvider = loginInfo.LoginProvider; info.LoginProviderDisplay = loginInfo.ProviderDisplayName; // Check whether this is an invited user using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) { List <DataProviderFilterInfo> filters = null; switch (config.RegistrationType) { default: case RegistrationTypeEnum.NameAndEmail: filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserName), Operator = "==", Value = info.Name, }); filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.Email), Operator = "==", Value = info.Email, }); break; case RegistrationTypeEnum.EmailOnly: filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.Email), Operator = "==", Value = info.Email, }); break; case RegistrationTypeEnum.NameOnly: filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserName), Operator = "==", Value = info.Name, }); break; } info.ExistingUser = await dataProvider.GetItemAsync(filters); } return(info); }
public async Task SendSMSAsync(string toNumber, string text, string FromNumber) { TwilioData config = await TwilioConfigDataProvider.GetConfigAsync(); string accountSid = config.TestMode ? config.TestAccountSid : config.LiveAccountSid; string authToken = config.TestMode ? config.TestAuthToken : config.LiveAuthToken; string fromNumber = config.TestMode ? config.TestSMSNumber : config.LiveSMSNumber; if (!string.IsNullOrWhiteSpace(FromNumber)) { fromNumber = FromNumber; } fromNumber = PhoneNumberNationalAttribute.GetE164(fromNumber); if (fromNumber == null) { throw new InternalError($"Invalid fromNumber {fromNumber} - {nameof(SendSMSAsync)}"); } toNumber = PhoneNumberNationalAttribute.GetE164(toNumber); if (toNumber == null) { throw new InternalError($"Invalid toNumber {toNumber} - {nameof(SendSMSAsync)}"); } string callbackUrl = null; if (config.DeliveryReceipts) { callbackUrl = YetaWFManager.Manager.CurrentSite.MakeUrl( Utility.UrlFor(typeof(TwilioResponseController), nameof(TwilioResponseController.Response), new { ValidateToNumber = toNumber }), PagePageSecurity: config.UseHttps?YetaWF.Core.Pages.PageDefinition.PageSecurityType.httpsOnly: YetaWF.Core.Pages.PageDefinition.PageSecurityType.httpOnly ); } TwilioClient.Init(accountSid, authToken); MessageResource m = MessageResource.Create( from: fromNumber, // From number, must be an SMS-enabled Twilio number to: toNumber, body: text, statusCallback: callbackUrl != null ? new Uri(callbackUrl) : null ); if (m.ErrorCode != null) { Logging.AddErrorLog("TwilioProcessor SendSMS failed: {0} {1} - {2} - {3}", fromNumber, toNumber, m.ErrorCode, m.ErrorMessage); } else { Logging.AddLog("TwilioProcessor SendSMS queued: {0} {1}", fromNumber, toNumber); } }
private IWorkItem PostProcessSelectedSuggestion(IWorkItem selectedSuggestion) { IWorkItem postProcessedSelectedSuggestion = null; try { postProcessedSelectedSuggestion = selectedSuggestion.GetProvider().GetParameterFromSelectedSuggestion(selectedSuggestion); } catch (Exception exception) { MessagesHandler.Display("Selected suggestion postprocess failed", exception.Message); Logging.AddErrorLog("Selected suggestion postprocess failed: " + exception.Message + ((exception.InnerException != null) ? ":" + exception.InnerException.Message : "")); Common.Logging.AddExceptionLog(exception); postProcessedSelectedSuggestion = null; } return(postProcessedSelectedSuggestion); }
public new ActionResult Response(string ValidateToNumber, string To, string From, string MessageSid, string MessageStatus, string ErrorCode) { if (ValidateToNumber != To) { Logging.AddErrorLog("Response from Twilio: Invalid (to number doesn't match) - {0}", Manager.CurrentRequestUrl); } else { if (ErrorCode != "0") { Logging.AddErrorLog("Response from Twilio: {0} {1} {2} {3} {4} {5}", From, To, ErrorCode, MessageStatus, MessageSid, Manager.CurrentRequestUrl); } else { Logging.AddLog("Response from Twilio: {0} {1} {2} {3} {4} {5}", From, To, ErrorCode, MessageStatus, MessageSid, Manager.CurrentRequestUrl); } } return(new EmptyResult()); }
private void ExecuteCommandCandidate(Command bestCandidateForUsedCommand) { try { if (bestCandidateForUsedCommand.Name != "repeat") { WorkItemsProviders.CommandsHistory.CommandsHistory.Add(bestCandidateForUsedCommand); } bestCandidateForUsedCommand.Execute(service); } catch (Exception exception) { MessagesHandler.Display("Command execution failed", exception.Message); Logging.AddErrorLog("Command execution failed: " + exception.Message + ((exception.InnerException != null)? ":" + exception.InnerException.Message + ((exception.InnerException.InnerException != null)? ":" + exception.InnerException.InnerException.Message: ""): "") ); Common.Logging.AddExceptionLog(exception); } }
/// <summary> /// Builds the current site from the zip files in the Data folder /// </summary> /// <param name="includeNonSiteSpecifics"></param> public async Task BuildSiteUsingDataAsync(bool includeNonSiteSpecifics, List <Package> installedPackages = null) { Manager.ImportChunksNonSiteSpecifics = includeNonSiteSpecifics; List <string> files = await FileSystem.FileSystemProvider.GetFilesAsync(Path.Combine(TemplateFolder, DataFolderName), "*.zip"); foreach (string file in files) { if (installedPackages == null || (from p in installedPackages where file.Contains($"{p.Name}.") select p).Any()) { List <string> errorList = new List <string>(); Logging.AddLog("Restoring {0}", file); if (!await Package.ImportDataAsync(file, errorList)) { Logging.AddErrorLog($"Error restoring {file} - {errorList.First()}"); //throw new Error(errorList.First()); } } } Manager.ImportChunksNonSiteSpecifics = false; await Resource.ResourceAccess.ShutTheBackDoorAsync(); }
private Dictionary <string, IWorkItem> GetAvailableSuggestions(Command bestCandidateForUsedCommand) { MessagesHandler.Display("Retrieving suggestions. Please wait..."); Dictionary <string, IWorkItem> suggestions = new Dictionary <string, IWorkItem>(); foreach (Type supportedParameterTypeProvider in bestCandidateForUsedCommand.supportedParameterTypeProviders) { try { Application.DoEvents(); IWorkItemsProvider ptp = Assembly.GetExecutingAssembly().CreateInstance(supportedParameterTypeProvider.FullName) as IWorkItemsProvider; foreach (KeyValuePair <string, IWorkItem> kv in SuggestionsCache.Get(ptp)) { IWorkItem existingWorkItemWithSameName = null; if (suggestions.TryGetValue(kv.Key, out existingWorkItemWithSameName)) { string message = string.Format("Can't add item '{0}' from provider '{1}' because item with same name allready loaded from provider {2}.", kv.Key, kv.Value.GetProvider().GetType().Name, existingWorkItemWithSameName.GetProvider().GetType().Name); Logging.AddErrorLog(message); //MessagesHandler.Display(message); } else { suggestions.Add(kv.Key, kv.Value); } } } catch (Exception exception) { MessagesHandler.Display("Error occured while retriving suggestions", exception.Message); Logging.AddErrorLog("Error occured while retriving suggestions: " + exception.Message + ((exception.InnerException != null) ? ":" + exception.InnerException.Message : "")); Common.Logging.AddExceptionLog(exception); } } MessagesHandler.HideAllMessages(); return(suggestions); }
public static List <Contact> GetContacts() { List <Contact> contacts = new List <Contact>(); try { string contactsFilePath = Settings.Current.CallerE61ContactsFilePath; CraftSynth.BuildingBlocks.IO.FileSystem.CreateFileIfItDoesNotExist(contactsFilePath); if (!File.Exists(contactsFilePath)) { throw new ApplicationException("File not found:" + contactsFilePath); } string[] lines = File.ReadAllLines(contactsFilePath); Entry entry = new Entry(); foreach (string line in lines) { if (string.IsNullOrEmpty(line)) { if (entry != null) { foreach (var detailKey in entry.details.Keys) { if (entry.caption.EndsWith(", ")) { entry.caption = entry.caption.Remove(entry.caption.LastIndexOf(", ")); } string caption = string.Format("{0} ({1}:{2})", entry.caption, detailKey, entry.details[detailKey]); contacts.Add(new Contact(caption, entry.details[detailKey])); } } entry = new Entry(); } else { string[] lineSides = line.Split(':'); lineSides[0] = lineSides[0].Trim(); lineSides[1] = lineSides[1].Trim(); if (!string.IsNullOrEmpty(lineSides[0]) && !string.IsNullOrEmpty(lineSides[1])) { if (lineSides[0].Contains("phone") || lineSides[0].Contains("mobile") || lineSides[0].Contains("email") ) { entry.details.Add(lineSides[0], lineSides[1]); } else { entry.caption += string.Format("{0}, ", lineSides[1]); } } } } } catch (Exception exception) { Logging.AddErrorLog("ExtensionCaller: SourceNokiaE61.GetContacts failed : " + exception.Message + ((exception.InnerException != null) ? ":" + exception.InnerException.Message : "")); Common.Logging.AddExceptionLog(exception); } return(contacts); }
public async Task ResolveUserAsync() { if (!Manager.HaveCurrentRequest) { throw new InternalError("No httpRequest"); } // check whether we have a logged on user #if MVC6 if (SiteDefinition.INITIAL_INSTALL || !Manager.CurrentContext.User.Identity.IsAuthenticated) #else if (SiteDefinition.INITIAL_INSTALL || !Manager.CurrentRequest.IsAuthenticated) #endif { return;// no user logged in } // get user info and save in Manager string userName = Manager.CurrentContext.User.Identity.Name; using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) { if (!await userDP.IsInstalledAsync()) { Logging.AddErrorLog("UserDefinitionDataProvider not installed"); return; } UserDefinition user = await userDP.GetItemAsync(userName); if (user == null) { Logging.AddErrorLog("Authenticated user {0} doesn't exist", userName); #if DEBUG //throw new InternalError("Authenticated user doesn't exist"); #endif return; } // Check whether user needs to set up two-step authentication // External login providers don't require local two-step authentication (should be offered by external login provider) // If any of the user's roles require two-step authentication and the user has not enabled two-step authentication providers, // set marker so we can redirect the user if (Manager.Need2FAState == null) { Manager.Need2FAState = false; using (UserLoginInfoDataProvider logInfoDP = new UserLoginInfoDataProvider()) { if (!await logInfoDP.IsExternalUserAsync(user.UserId)) { // not an external login, so check if we need two-step auth LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync(); if (config.TwoStepAuth != null && user.RolesList != null) { foreach (Role role in config.TwoStepAuth) { if (role.RoleId == Resource.ResourceAccess.GetUserRoleId() || user.RolesList.Contains(new Role { RoleId = role.RoleId }, new RoleComparer())) { if ((await user.GetEnabledAndAvailableTwoStepAuthenticationsAsync()).Count == 0) { Manager.Need2FAState = true; } break; } } } } } } // Check whether the user needs to change the password Manager.NeedNewPassword = user.NeedsNewPassword; // user good to go Manager.UserName = user.UserName; Manager.UserEmail = user.Email; Manager.UserId = user.UserId; Manager.UserObject = user; await UserSettings.UserSettingsAccess.ResolveUserAsync(); Manager.UserRoles = (from l in user.RolesList select l.RoleId).ToList(); int superuserRole = Resource.ResourceAccess.GetSuperuserRoleId(); if (user.RolesList.Contains(new Role { RoleId = superuserRole }, new RoleComparer())) { Manager.SetSuperUserRole(true); } } }
private async Task <ActionResult> RunEntryAsync(IVRConfig ivrConfig, ScriptData script, string called, string extension, ScriptEntry entry, int errCount) { string extensionName = null; string extensionSpaced = null; if (!string.IsNullOrWhiteSpace(extension)) { extensionSpaced = Spaced(extension); Extension e = script.FindExtension(extension); if (e != null) { extensionName = e.Name; } } string digits; TryGetForm("Digits", out digits); string actionUrl = Utility.UrlFor(typeof(CallController), nameof(Process)); #if DEBUG actionUrl = Manager.CurrentSite.MakeFullUrl(actionUrl, SecurityType: YetaWF.Core.Pages.PageDefinition.PageSecurityType.Any); #else actionUrl = Manager.CurrentSite.MakeFullUrl(actionUrl, SecurityType: YetaWF.Core.Pages.PageDefinition.PageSecurityType.httpsOnly); #endif string token = DateTime.UtcNow.Ticks.ToString(); string encryptedToken; RSACrypto.Encrypt(ivrConfig.PublicKey, token, out encryptedToken); object parms = new { Url = actionUrl, Caller = GetForm("Caller"), CallerSpaced = Spaced(GetForm("Caller").TruncateStart("+1")), CallerCity = GetForm("CallerCity"), CallerCountry = GetForm("CallerCountry"), Digits = digits, Extension = extension, ExtensionSpaced = extensionSpaced, ExtensionName = extensionName, ErrCount = errCount, ErrCountPlus1 = errCount + 1, Token = encryptedToken, Voice = ivrConfig.Voice, VoiceInternal = ivrConfig.VoiceInternal, }; string text = entry.Text; Variables vars = new Variables(Manager, parms) { EncodingType = Variables.EncodingTypeEnum.XML }; Extension ext = script.FindExtension(digits); if (ext != null) { text = RepeatableNumbers(ext, text); } if (text.Contains("RECORDVOICEMAIL")) { text = text.Replace("RECORDVOICEMAIL", ""); VoiceMailData voiceMail; using (VoiceMailDataProvider voiceMailDP = new VoiceMailDataProvider()) { voiceMail = new VoiceMailData { Caller = GetForm("Caller").Truncate(Globals.MaxPhoneNumber), CallerCity = GetForm("CallerCity").Truncate(VoiceMailData.MaxCity), CallerState = GetForm("CallerState").Truncate(VoiceMailData.MaxState), CallerZip = GetForm("CallerZip").Truncate(VoiceMailData.MaxZip), CallerCountry = GetForm("CallerCountry").Truncate(VoiceMailData.MaxCountry), CallSid = GetForm("CallSid"), RecordingSid = GetForm("RecordingSid"), Duration = ConvertToInt(GetForm("RecordingDuration")), To = called, Extension = extension, RecordingUrl = GetForm("RecordingUrl").Truncate(Globals.MaxUrl) }; if (!await voiceMailDP.AddItemAsync(voiceMail)) { Logging.AddErrorLog($"Couldn't record voice mail status for call from {GetForm("Caller")}"); } } if (!string.IsNullOrWhiteSpace(extension)) { ext = script.FindExtension(extension); if (ext != null) { DisplayVoiceMailModule dispMod = (DisplayVoiceMailModule)await ModuleDefinition.LoadAsync(ModuleDefinition.GetPermanentGuid(typeof(DisplayVoiceMailModule))); ModuleAction displayAction = await dispMod.GetAction_DisplayAsync(null, voiceMail.Id); if (displayAction != null) { string viewUrl = displayAction.GetCompleteUrl(); foreach (ExtensionNumber extNumber in ext.Numbers) { if (extNumber.SendSMSVoiceMail) { SendSMS sendSMS = new SendSMS(); await sendSMS.SendMessageAsync(extNumber.Number, this.__ResStr("voiceSMS", "A voice mail was received for extension {0} ({1}) from {2}, {3}, {4}, {5} {6} - {7}", extension, GetForm("To"), GetForm("Caller"), GetForm("CallerCity"), GetForm("CallerState"), GetForm("CallerZip"), GetForm("CallerCountry"), viewUrl), ThrowError : false); } } } } } } text = vars.ReplaceVariables(text); Logging.AddLog($"{nameof(RunEntryAsync)}: {text}"); return(Content(text, "text/xml")); }
private async Task <List <Package> > InstallPackagesAsync(List <string> wantedPackages) { Logging.AddLog("Installing packages"); // get all packages that are available List <Package> allPackages = Package.GetAvailablePackages(); // get packages to install, limit to wanted packages List <Package> remPackages = allPackages.ToList(); if (wantedPackages != null) { remPackages = (from p in remPackages where wantedPackages.Contains(p.Name) select p).ToList(); } // add all required dependencies from packages even if they were not initially wanted foreach (Package remPackage in remPackages.ToList()) { AddDependencies(remPackages, remPackage); } // order all available packages by service level remPackages = (from p in remPackages orderby(int) p.ServiceLevel select p).ToList(); // keep track of installed packages List <Package> installedPackages = new List <Package>(); List <Package> remainingPackages = (from p in remPackages select p).ToList(); // check each package and install it if all dependencies are available for ( ; remPackages.Count() > installedPackages.Count();) { int count = 0; foreach (Package package in remPackages) { List <string> errorList = new List <string>(); if (!installedPackages.Contains(package)) { Logging.AddLog("Installing package {0}", package.Name); if (ArePackageDependenciesInstalled(package, installedPackages)) { if (!await package.InstallModelsAsync(errorList)) { ScriptBuilder sb = new ScriptBuilder(); sb.Append(this.__ResStr("cantInstallPackage", "Can't install package {0}:(+nl)"), package.Name); sb.Append(errorList, LeadingNL: true); throw new Error(sb.ToString()); } ++count; installedPackages.Add(package); remainingPackages.Remove(package); } } } if (count == 0) // we didn't install any additional packages { Logging.AddErrorLog("Not all packages could be installed"); foreach (Package package in remainingPackages) { List <string> reqPackages = package.GetRequiredPackages(); Logging.AddErrorLog($"Package {package.Name} not installed - Requires {string.Join(", ", reqPackages)}"); foreach (string dep in reqPackages) { if (!(from p in installedPackages where p.Name == dep select p).Any()) { Logging.AddErrorLog($" Package dependency {dep} not installed and is required by {package.Name}"); } } } throw new InternalError("Not all packages could be installed"); } } return(installedPackages); }
public async Task <IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null) { if (remoteError != null) { throw new Error(this.__ResStr("extErr", "The external login provider reported this error: {0}", remoteError)); } SignInManager <UserDefinition> _signinManager = (SignInManager <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(SignInManager <UserDefinition>)); ExternalLoginInfo loginInfo = await _signinManager.GetExternalLoginInfoAsync(); if (loginInfo == null) { Logging.AddErrorLog("AuthenticationManager.GetExternalLoginInfoAsync() returned null"); return(Redirect(Helper.GetSafeReturnUrl(Manager.CurrentSite.LoginUrl))); } using (LoginConfigDataProvider logConfigDP = new LoginConfigDataProvider()) { List <LoginConfigDataProvider.LoginProviderDescription> loginProviders = await logConfigDP.GetActiveExternalLoginProvidersAsync(); if ((from l in loginProviders where l.InternalName == loginInfo.LoginProvider select l).FirstOrDefault() == null) { Logging.AddErrorLog("Callback from external login provider {0} which is not active", loginInfo.LoginProvider); return(Redirect(Helper.GetSafeReturnUrl(Manager.CurrentSite.LoginUrl))); } } // get our registration defaults LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync(); // Sign in the user with this external login provider if the user already has a login UserDefinition user = await Managers.GetUserManager().FindByLoginAsync(loginInfo.LoginProvider, loginInfo.ProviderKey); if (user == null) { // If the user does not have an account, then prompt the user to create an account // we will go to a page where the user can set up a local account Manager.OriginList = new List <Origin>(); if (!string.IsNullOrWhiteSpace(returnUrl)) { Manager.OriginList.Add(new Origin() { Url = returnUrl }); // where to go after setup } Manager.OriginList.Add(new Origin() { Url = Helper.GetSafeReturnUrl(Manager.CurrentSite.ExternalAccountSetupUrl) }); // setup return(Redirect(Manager.ReturnToUrl)); } if (string.IsNullOrWhiteSpace(returnUrl) && Manager.HaveReturnToUrl) { returnUrl = Manager.ReturnToUrl; } if (string.IsNullOrWhiteSpace(returnUrl)) { returnUrl = await Resource.ResourceAccess.GetUserPostLoginUrlAsync((from u in user.RolesList select u.RoleId).ToList()); } if (string.IsNullOrWhiteSpace(returnUrl)) { returnUrl = Manager.CurrentSite.PostLoginUrl; } returnUrl = Helper.GetSafeReturnUrl(returnUrl); // determine what to do based on account status if (user.UserStatus == UserStatusEnum.Approved) { await LoginModuleController.UserLoginAsync(user); Logging.AddLog("User {0} - logged on", user.UserName); returnUrl = QueryHelper.AddRando(returnUrl); // to defeat client-side caching return(Redirect(returnUrl)); } else if (user.UserStatus == UserStatusEnum.Rejected) { await LoginModuleController.UserLogoffAsync(); Logging.AddErrorLog("User {0} - rejected user", user.UserName); if (string.IsNullOrWhiteSpace(config.RejectedUrl)) { return(Redirect(MessageUrl("Your account has been rejected by the site administrator."))); } return(Redirect(Helper.GetSafeReturnUrl(config.RejectedUrl))); } else if (user.UserStatus == UserStatusEnum.Suspended) { await LoginModuleController.UserLogoffAsync(); Logging.AddErrorLog("User {0} - suspended user", user.UserName); if (string.IsNullOrWhiteSpace(config.SuspendedUrl)) { return(Redirect(MessageUrl("Your account has been suspended by the site administrator."))); } return(Redirect(Helper.GetSafeReturnUrl(config.SuspendedUrl))); } else if (user.UserStatus == UserStatusEnum.NeedValidation) { await LoginModuleController.UserLogoffAsync(); Logging.AddErrorLog("User {0} - not yet validated", user.UserName); if (string.IsNullOrWhiteSpace(config.VerificationPendingUrl)) { return(Redirect(MessageUrl(this.__ResStr("notValidated", "Your account has not yet been verified. You will receive an email with verification information. Once received, please use the information in the email to complete the registration.")))); } return(Redirect(Helper.GetSafeReturnUrl(config.VerificationPendingUrl))); } else if (user.UserStatus == UserStatusEnum.NeedApproval) { await LoginModuleController.UserLogoffAsync(); Logging.AddErrorLog("User {0} - not yet approved", user.UserName); if (string.IsNullOrWhiteSpace(config.ApprovalPendingUrl)) { return(Redirect(MessageUrl(this.__ResStr("notApproved", "Your account has not yet been approved by the site administrator. You will receive an email confirmation as soon as your account is active.")))); } return(Redirect(Helper.GetSafeReturnUrl(config.ApprovalPendingUrl))); } else { await LoginModuleController.UserLogoffAsync(); throw new InternalError("badUserStatus", "Unexpected account status {0}", user.UserStatus); } }
public void ExecuteCommand(Extension.IEnsoService service, Command command) { Logging.AddActionLog(string.Format("FileManager: Executing command '{0}' ...", command.Name)); if (command.Name == "copy to" || command.Name == "move to") { string selectedPath = service.GetUnicodeSelection(); if (string.IsNullOrEmpty(selectedPath)) { selectedPath = service.GetFileSelection()[0]; } if (string.IsNullOrEmpty(selectedPath)) { MessagesHandler.Display("Nothing is selected therefore no destination path."); Logging.AddErrorLog("FileManager: Nothing is selected therefore no destination path."); } else { try { string destinationPath = Path.Combine(command.parametersOnExecute[0].GetValueAsText(), Path.GetFileName(selectedPath)); if (command.Name == "copy to") { Logging.AddActionLog(string.Format("FileManager: Copying '{0}' to {1} ...", selectedPath, command.parametersOnExecute[0].GetValueAsText())); CraftSynth.BuildingBlocks.IO.FileSystem.CopyFileOrFolder(selectedPath, command.parametersOnExecute[0].GetValueAsText()); if (CraftSynth.BuildingBlocks.IO.FileSystem.FileOrFolderExist(destinationPath)) { Logging.AddActionLog("FileManager: Copied."); MessagesHandler.Display("Copied."); } else { string errorMessage = string.Format("Destination file/folder '{0}' does not exist after copy operation.", destinationPath); Logging.AddErrorLog(string.Format("FileManager: {0}", errorMessage)); MessagesHandler.Display(errorMessage); } } else if (command.Name == "move to") { Logging.AddActionLog(string.Format("FileManager: Moving '{0}' to {1} ...", selectedPath, command.parametersOnExecute[0].GetValueAsText())); CraftSynth.BuildingBlocks.IO.FileSystem.MoveFileOrFolder(selectedPath, command.parametersOnExecute[0].GetValueAsText()); if (CraftSynth.BuildingBlocks.IO.FileSystem.FileOrFolderDoesNotExist(destinationPath)) { string errorMessage = string.Format("Destination file/folder '{0}' does not exist after move operation.", destinationPath); Logging.AddErrorLog(string.Format("FileManager: {0}", errorMessage)); MessagesHandler.Display(errorMessage); } else if (CraftSynth.BuildingBlocks.IO.FileSystem.FileOrFolderExist(selectedPath)) { string errorMessage = string.Format("Destination file/folder '{0}' still exist after move operation.", destinationPath); Logging.AddErrorLog(string.Format("FileManager: {0}", errorMessage)); MessagesHandler.Display(errorMessage); } else { Logging.AddActionLog("FileManager: Moved."); MessagesHandler.Display("Moved."); } } } catch (System.IO.FileNotFoundException) { Logging.AddErrorLog(string.Format("FileManager: File not found: {0}", command.parametersOnExecute[1].GetValueAsText())); MessagesHandler.Display("File not found.", command.parametersOnExecute[1].GetValueAsText()); } catch (System.IO.DirectoryNotFoundException) { Logging.AddErrorLog(string.Format("FileManager: Folder not found: {0}", command.parametersOnExecute[1].GetValueAsText())); MessagesHandler.Display("Folder not found.", command.parametersOnExecute[1].GetValueAsText()); } catch (Exception exception) { Logging.AddErrorLog(string.Format("FileManager: {0}", exception.Message)); MessagesHandler.Display(exception.Message); } } } else if (command.Name == "empty") { string path = command.parametersOnExecute[0].GetValueAsText(); Logging.AddActionLog(string.Format("FileManager: Emptying '{0}' ...", path)); bool isFolder = true; if (File.Exists(path) && !Directory.Exists(path)) { isFolder = false; } else if (!File.Exists(path) && Directory.Exists(path)) { isFolder = true; } try { Logging.AddActionLog(string.Format("FileManager: Deleting '{0}' ...", path)); CraftSynth.BuildingBlocks.IO.FileSystem.DeleteFileOrFolder(path, false); if (!isFolder) { Logging.AddActionLog(string.Format("FileManager: Creating '{0}' ...", path)); File.Create(path); } else { Logging.AddActionLog(string.Format("FileManager: Creating '{0}' ...", path)); Directory.CreateDirectory(path); } Logging.AddActionLog("FileManager: Contents deleted."); MessagesHandler.Display("Contents deleted."); } catch (System.IO.FileNotFoundException) { Logging.AddErrorLog(string.Format("FileManager: File not found: {0}", command.parametersOnExecute[1].GetValueAsText())); MessagesHandler.Display("File not found.", command.parametersOnExecute[1].GetValueAsText()); } catch (System.IO.DirectoryNotFoundException) { Logging.AddErrorLog(string.Format("FileManager: Folder not found: {0}", command.parametersOnExecute[1].GetValueAsText())); MessagesHandler.Display("Folder not found.", command.parametersOnExecute[1].GetValueAsText()); } catch (Exception exception) { //if operation failed but item is empty report success if (!isFolder && File.Exists(path)) { FileInfo fileInfo = new FileInfo(path); if (fileInfo.Length == 0) { exception = null; } } else if (Directory.Exists(path)) { if (CraftSynth.BuildingBlocks.IO.FileSystem.GetFilePaths(path).Count == 0 && CraftSynth.BuildingBlocks.IO.FileSystem.GetFolderPaths(path).Count == 0) { exception = null; } } if (exception == null) { Logging.AddActionLog("FileManager: Contents deleted."); MessagesHandler.Display("Contents deleted."); } else { Logging.AddErrorLog(string.Format("FileManager: {0}", exception.Message)); MessagesHandler.Display(exception.Message); } } } else if ((command.Name == "save" && command.Postfix == "[what] to") || (command.Name == "save" && command.Postfix == "[what] and copy its file path")) { ParameterizedThreadStart ts = new ParameterizedThreadStart(ProcessCommand); clipboardHost = new Thread(ts); clipboardHost.SetApartmentState(ApartmentState.STA); KeyValuePair <IEnsoService, Command> parameters = new KeyValuePair <IEnsoService, Command>(service, command); clipboardHost.Start(parameters); clipboardHost.Join(); } else if (command.Name == "copy file content as text") { string filePath = command.parametersOnExecute[0].GetValueAsText(); string content = File.ReadAllText(filePath); if (string.Empty == (content.Trim())) { MessagesHandler.Display(string.Format("File is empty.", filePath)); } else { CraftSynth.BuildingBlocks.IO.Clipboard.SetTextToClipboard(content); //content = BuildingBlocks.DataAccess.Clipboard.Helper.GetTextFromClipboard(); string message = content.Substring(0, (content.Length <= 200) ? content.Length : 200); if (content.Length > 200) { message = message + "..."; } try { MessagesHandler.Display(message, string.Format("{0} characters on clipboard", content.Length)); } catch { MessagesHandler.Display(string.Format("Copied {0} characters.", content.Length)); } } } // else // if (command.Name == "command name" && command.Postfix == "postfix [item] [item2]") // { // MessagesHandler.Display( string.Format("Executing {0} ...", command.Name)); // } else { throw new ApplicationException(string.Format("FileManager: Command not found. Command: {0} {1}", command.Name, command.Postfix)); } }
public void OnCommand(EnsoCommand ensoCommand, string postfix, IntPtr foregroundWindowForGrab) { Logging.AddDebugLog("OnCommand:" + ensoCommand.Name + " postfix:" + postfix + "------------------------------------------------------------------------------------------------"); try { //SelectionListener.Listener.Current.IfOpenedPause(); MergedCommand mergedCommand = this.mergedCommands[ensoCommand.Name]; //if none of potentially chosen commands use selection skip expensive operations: // this.service.GetFileSelection() and/or this.service.GetUnicodeSelection(); bool skipGetUnicodeSelection = true; bool skipGetFileSelection = true; foreach (var sourceCommand in mergedCommand.sourceCommands) { if (sourceCommand.canUseTextSelectionForParameter) { skipGetUnicodeSelection = false; } if (sourceCommand.canUseFileSelectionForParameter) { skipGetFileSelection = false; } if (!skipGetUnicodeSelection && !skipGetFileSelection) { break; } } Logging.AddDebugLog("OnCommand: skipGetUnicodeSelection=" + skipGetUnicodeSelection + " skipGetFilesSelection=" + skipGetFileSelection); //do we need file selection? if ((ensoCommand.Name == "topen" || ensoCommand.Name == "rtopen" || ensoCommand.Name == "empty")) { try { if (CraftSynth.BuildingBlocks.WindowsNT.Misc.GetForegroundWindowCaption().Contains("Total Commander")) { skipGetFileSelection = true; } } catch { } } //read selection ClipboardData selectedData = null; if (!skipGetUnicodeSelection || !skipGetFileSelection) { selectedData = HandlerForSelection.Get(foregroundWindowForGrab); } Logging.AddDebugLog("OnCommand: first 100 chars of HandlerForSelection.Get=" + (selectedData == null?"null":selectedData.AsUnicodeText).FirstXChars(100, "...")); //Get text selection if needed string selectedText = null; if (!skipGetUnicodeSelection && selectedData != null) { selectedText = selectedData.AsUnicodeText; } Logging.AddDebugLog("OnCommand: first 100 chars of selectedText=" + (selectedText ?? "null").FirstXChars(100, "...")); //Get file selection if needed string[] fileSelectionArray = null; if (!skipGetFileSelection && !skipGetUnicodeSelection && string.IsNullOrEmpty(selectedText) && selectedData != null) { var ffl = selectedData.AsFileFolderList; if (ffl == null) { fileSelectionArray = null; } else { fileSelectionArray = ffl.ToArray(); } ; //ex: this.service.GetFileSelection(); } else { fileSelectionArray = new string[] { }; } Logging.AddDebugLog("OnCommand: first 100 chars of fileSelectionArray=" + (fileSelectionArray == null? "null": Syntax.FileSelectionArrayToString(fileSelectionArray)).FirstXChars(100, "...")); if (fileSelectionArray != null && fileSelectionArray.Length > 0 && string.IsNullOrEmpty(selectedText)) { selectedText = Syntax.FileSelectionArrayToString(fileSelectionArray); } Command bestCandidateForUsedCommand = null; bool bestCandidateForUsedCommandRequiresParameterInput = false; foreach (Command sourceCommand in mergedCommand.sourceCommands) { Logging.AddDebugLog("OnCommand: Syntax.ExtractParameterValues..."); int parameterCountInSyntax = 0; List <string> parametersFromInlineCommand = Syntax.ExtractParameterValues(sourceCommand.Postfix, postfix, (GetSelectionForCommand(selectedText, sourceCommand)), mergedCommand.sourceCommands.Count == 1, out parameterCountInSyntax); Logging.AddDebugLog("OnCommand: parametersFromInlineCommand=" + (parametersFromInlineCommand == null?"null":parametersFromInlineCommand.ToCSV())); if (parametersFromInlineCommand == null) { continue; } //replace jockers - should be refactored Logging.AddDebugLog("OnCommand: replace jockers..."); int i = parametersFromInlineCommand.Count - 1; while (i >= 0) { if (parametersFromInlineCommand[i] == Syntax.lastMessageInPostfix) { parametersFromInlineCommand[i] = MessagesHandler.GetLastFromHistory().Text; } else if (parametersFromInlineCommand[i] == Syntax.selectionInPostfix1 || parametersFromInlineCommand[i] == Syntax.selectionInPostfix2) { parametersFromInlineCommand.RemoveAt(i); } i--; } Logging.AddDebugLog("OnCommand: Determine best candidate..."); if ((GetSelectionForCommand(selectedText, sourceCommand) == string.Empty && parametersFromInlineCommand.Count == parameterCountInSyntax) || (parameterCountInSyntax == 0 && sourceCommand.Postfix == " ") || (GetSelectionForCommand(selectedText, sourceCommand) != string.Empty && parametersFromInlineCommand.Count == parameterCountInSyntax && GetSelectionForCommand(selectedText, sourceCommand).CompareTo(parametersFromInlineCommand[parametersFromInlineCommand.Count - 1]) == 0)) { bestCandidateForUsedCommand = sourceCommand.GetClone(); bestCandidateForUsedCommand.parametersOnExecute = StringWorkItem.CreateInstances(parametersFromInlineCommand); bestCandidateForUsedCommandRequiresParameterInput = false; Logging.AddDebugLog("OnCommand: bc=a"); break; } else if (GetSelectionForCommand(selectedText, sourceCommand) != string.Empty && parametersFromInlineCommand.Count == parameterCountInSyntax && GetSelectionForCommand(selectedText, sourceCommand).CompareTo(parametersFromInlineCommand[parametersFromInlineCommand.Count - 1]) != 0) { bestCandidateForUsedCommand = sourceCommand.GetClone(); bestCandidateForUsedCommand.parametersOnExecute = StringWorkItem.CreateInstances(parametersFromInlineCommand); bestCandidateForUsedCommandRequiresParameterInput = false; Logging.AddDebugLog("OnCommand: bc=b"); } else if (parametersFromInlineCommand.Count == (parameterCountInSyntax - 1)) { bestCandidateForUsedCommand = sourceCommand.GetClone(); bestCandidateForUsedCommand.parametersOnExecute = StringWorkItem.CreateInstances(parametersFromInlineCommand); bestCandidateForUsedCommandRequiresParameterInput = true; Logging.AddDebugLog("OnCommand: bc=c"); } } if (bestCandidateForUsedCommand == null) { Logging.AddDebugLog("OnCommand: postfix Invalid!"); MessagesHandler.Display("Postfix invalid!", ensoCommand.Name + " " + ensoCommand.Postfix); } else { Logging.AddDebugLog("OnCommand: bestCandidateForUsedCommand=" + bestCandidateForUsedCommand.Name); Logging.AddDebugLog("OnCommand: replace 'last' parameter with last used parameter/WorkItem"); //replace 'last' parameter with last used parameter/WorkItem int j = 0; while (j < bestCandidateForUsedCommand.parametersOnExecute.Count) { Logging.AddDebugLog("OnCommand: first 100 chars of paramsOnExecute[" + j + "]=" + (bestCandidateForUsedCommand.parametersOnExecute[j].GetValueAsText().FirstXChars(100, "..."))); if (bestCandidateForUsedCommand.parametersOnExecute[j].GetValueAsText() == Syntax.lastParameterInPostfix) { bestCandidateForUsedCommand.parametersOnExecute[j] = WorkItemsProviders.CommandsHistory.CommandsHistory.GetLastWorkItem(); Logging.AddDebugLog("OnCommand: first 100 chars of paramsOnExecute[" + j + "]=" + bestCandidateForUsedCommand.parametersOnExecute[j].GetValueAsText().FirstXChars(100, "...")); } j++; } if (bestCandidateForUsedCommand.parameterInputArguments.acceptOnlySuggested && !bestCandidateForUsedCommandRequiresParameterInput && bestCandidateForUsedCommand.parametersOnExecute.Count > 0) {//user entered all parameters and command uses cloased parameter group Logging.AddDebugLog("OnCommand: user entered all parameters and command uses cloased parameter group"); Dictionary <string, IWorkItem> suggestions = GetAvailableSuggestions(bestCandidateForUsedCommand); IWorkItem selectedSuggestion = null; if (suggestions.TryGetValue(bestCandidateForUsedCommand.parametersOnExecute[bestCandidateForUsedCommand.parametersOnExecute.Count - 1].GetCaption(), out selectedSuggestion)) {//user-entered parameter does not exist in group - add it to list Logging.AddDebugLog("OnCommand: user-entered parameter does not exist in group - add it to list"); IWorkItem postProcessedSuggestion = PostProcessSelectedSuggestion(selectedSuggestion); if (postProcessedSuggestion == null) {//user probably canceled command - abort command Logging.AddDebugLog("OnCommand: user probably canceled command - abort command"); return; } bestCandidateForUsedCommand.parametersOnExecute[bestCandidateForUsedCommand.parametersOnExecute.Count - 1] = postProcessedSuggestion; } else {//user-entered parameter does not exist in group - plan input parameter box Logging.AddDebugLog("OnCommand: user-entered parameter does not exist in group - plan input parameter box"); if (bestCandidateForUsedCommand.parameterInputArguments.acceptOnlySuggested) { bestCandidateForUsedCommand.parameterInputArguments.predefinedValue = string.Empty; } else { bestCandidateForUsedCommand.parameterInputArguments.predefinedValue = bestCandidateForUsedCommand.parametersOnExecute[bestCandidateForUsedCommand.parametersOnExecute.Count - 1].GetCaption(); } bestCandidateForUsedCommand.parametersOnExecute.RemoveAt(bestCandidateForUsedCommand.parametersOnExecute.Count - 1); bestCandidateForUsedCommandRequiresParameterInput = true; } } if (!bestCandidateForUsedCommandRequiresParameterInput) { Logging.AddDebugLog("OnCommand: bestCandidateForUsedCommandRequiresParameterInput==false"); Logging.AddDebugLog("OnCommand: ExecuteCommandCandidate..."); ExecuteCommandCandidate(bestCandidateForUsedCommand); } else { Logging.AddDebugLog("OnCommand: ProcessingBeforeParameterInput..."); bool cancel = false; bestCandidateForUsedCommand.provider.ProcessingBeforeParameterInput(bestCandidateForUsedCommand, ref cancel); Logging.AddDebugLog("OnCommand: ProcessingBeforeParameterInput done. cancel=" + cancel); if (cancel) { return; } Logging.AddDebugLog("OnCommand: GetAvailableSuggestions..."); Dictionary <string, IWorkItem> suggestions = GetAvailableSuggestions(bestCandidateForUsedCommand); //prepare parameters to suggestions bestCandidateForUsedCommand.parameterInputArguments.suggestions = new List <string>(); foreach (var suggestion in suggestions) { bestCandidateForUsedCommand.parameterInputArguments.suggestions.Add(suggestion.Key); } //execute dropbox Logging.AddDebugLog("OnCommand: execute dropbox..."); try { PostParameterInputArguments contextData = new PostParameterInputArguments(); contextData.suggestions = suggestions; contextData.bestCandidateForUsedCommand = bestCandidateForUsedCommand; contextData.bestCandidateForUsedCommandRequiresParameterInput = bestCandidateForUsedCommandRequiresParameterInput; ParameterInput.Display(bestCandidateForUsedCommand.parameterInputArguments, ParameterInput_OnClose, contextData, Screen.FromPoint(Cursor.Position)); } catch (Exception exception) { MessagesHandler.Display("Error", exception.Message); Logging.AddErrorLog("Parameter input failed: " + exception.Message + ((exception.InnerException != null) ? ":" + exception.InnerException.Message : "")); Common.Logging.AddExceptionLog(exception); } } } } catch (Exception exception) { Logging.AddErrorLog("Command execution failed: " + exception.Message + ((exception.InnerException != null) ? ":" + exception.InnerException.Message : "")); Logging.AddExceptionLog(exception); throw exception; } //SelectionListener.Listener.Current.IfOpenedContinue(); }
public static Shortcut ReadShortcutFile(string shortcutFilePath) { //File.AppendAllText("d:\\sss.txt", shortcutFilePath+"\r\n"); Shortcut result = null; try { //if( // Path.GetInvalidPathChars().Any(c=>Path.GetDirectoryName(shortcutFilePath).Contains(c)) || // Path.GetInvalidFileNameChars().Any(c=>Path.GetFileName(shortcutFilePath).Contains(c)) // ) //{ // result = null; //} //else { if (Path.GetExtension(shortcutFilePath).EndsWith("lnk", StringComparison.InvariantCultureIgnoreCase)) { try { string target = null; if (!CraftSynth.BuildingBlocks.WindowsNT.Misc.Is64BitOperatingSystem) { //requires Interop.IWshRuntimeLibrary which can not run as x64!! IWshRuntimeLibrary.WshShell shell = new IWshRuntimeLibrary.WshShell(); IWshRuntimeLibrary.IWshShortcut wshShortcut = (IWshRuntimeLibrary.IWshShortcut)shell.CreateShortcut(shortcutFilePath); target = wshShortcut.TargetPath; if ( //!shortcut.TargetPath.StartsWith("http", StringComparison.InvariantCultureIgnoreCase) && //!shortcut.TargetPath.StartsWith("ftp", StringComparison.InvariantCultureIgnoreCase) !string.IsNullOrEmpty(target) //make sure that target is on file system ) { Shortcut shortcut = new Shortcut(); shortcut.caption = Path.GetFileNameWithoutExtension(shortcutFilePath); shortcut.targetPath = target; shortcut.shortcutFilePath = shortcutFilePath; result = shortcut; } else { Shortcut shortcut = new Shortcut(); shortcut.caption = Path.GetFileNameWithoutExtension(shortcutFilePath); shortcut.targetPath = CraftSynth.BuildingBlocks.IO.FileSystem.GetTargetPathFromLnkManualy(shortcutFilePath); shortcut.shortcutFilePath = shortcutFilePath; result = shortcut; } } else { //run separate process as x86 and send it lnk filepath. FormLnkFileReaderProxy.Initialize(); target = FormLnkFileReaderProxy.WaitForLnkTarget(shortcutFilePath); if (!string.IsNullOrEmpty(target)) { Shortcut shortcut = new Shortcut(); shortcut.caption = Path.GetFileNameWithoutExtension(shortcutFilePath); shortcut.targetPath = target; shortcut.shortcutFilePath = shortcutFilePath; result = shortcut; } } } catch (Exception exception) { result = null; Logging.AddErrorLog(string.Format("Error occured while reading shortcut '{0}': {1}", shortcutFilePath, exception.Message)); Common.Logging.AddExceptionLog(exception); } } else if (Path.GetExtension(shortcutFilePath).EndsWith("url", StringComparison.InvariantCultureIgnoreCase)) { string targetPath = null; try { string[] content = System.IO.File.ReadAllLines(shortcutFilePath); targetPath = content.Single(l => l.ToUpper().StartsWith("URL=")).Split('=')[1].Trim(); Shortcut shortcut = new Shortcut(); shortcut.caption = Path.GetFileNameWithoutExtension(shortcutFilePath); shortcut.targetPath = targetPath; shortcut.shortcutFilePath = shortcutFilePath; result = shortcut; } catch (Exception exception) { result = null; Logging.AddErrorLog(string.Format("Error occured while reading shortcut '{0}': {1}", shortcutFilePath, exception.Message)); Common.Logging.AddExceptionLog(exception); } } //} } catch (Exception exception) { result = null; Logging.AddErrorLog(string.Format("Error occured while reading shortcut '{0}': {1}", shortcutFilePath, exception.Message)); Common.Logging.AddExceptionLog(exception); } return(result); }
public async Task SearchSiteAsync(bool slow) { SearchConfigData searchConfig = await SearchConfigDataProvider.GetConfigAsync(); DateTime searchStarted = DateTime.UtcNow; // once we have all new keywords, delete all keywords that were added before this date/time using (SearchDataProvider searchDP = new SearchDataProvider()) { // Search all generated pages (unique modules or classes, like data providers) DynamicUrlsImpl dynamicUrls = new DynamicUrlsImpl(); List <Type> types = dynamicUrls.GetDynamicUrlTypes(); // search types that generate dynamic urls foreach (Type type in types) { #if DEBUG // if (type.Name != "FileDocumentDisplayModule") continue;//used for debugging #endif ISearchDynamicUrls iSearch = Activator.CreateInstance(type) as ISearchDynamicUrls; if (iSearch != null) { try { SearchWords searchWords = new SearchWords(searchConfig, searchDP, searchStarted); await iSearch.KeywordsForDynamicUrlsAsync(searchWords); if (slow) { Thread.Sleep(500);// delay a bit (slow can only be used by scheduler items) } } catch (Exception exc) { Logging.AddErrorLog("KeywordsForDynamicUrls failed for {0}", type.FullName, exc); } } } // search all designed modules that have dynamic urls foreach (DesignedModule desMod in await DesignedModules.LoadDesignedModulesAsync()) { try { ModuleDefinition mod = await ModuleDefinition.LoadAsync(desMod.ModuleGuid, AllowNone : true); if (mod != null && types.Contains(mod.GetType()) && mod.WantSearch) { ISearchDynamicUrls iSearch = mod as ISearchDynamicUrls; if (iSearch != null) { SearchWords searchWords = new SearchWords(searchConfig, searchDP, searchStarted); await iSearch.KeywordsForDynamicUrlsAsync(searchWords); if (slow) { Thread.Sleep(500);// delay a bit (slow can only be used by scheduler items) } } } } catch (Exception exc) { Logging.AddErrorLog("KeywordsForDynamicUrls failed for module {0}", desMod.ModuleGuid, exc); } } // Search all designed pages and extract keywords List <Guid> pages = await PageDefinition.GetDesignedGuidsAsync(); foreach (Guid pageGuid in pages) { PageDefinition page = await PageDefinition.LoadAsync(pageGuid); if (page != null) { SearchWords searchWords = new SearchWords(searchConfig, searchDP, searchStarted); await SearchPageAsync(searchWords, page); if (slow) { Thread.Sleep(500);// delay a bit (slow can only be used by scheduler items) } } } // Remove old keywords await searchDP.RemoveOldItemsAsync(searchStarted); } }
public void ExecuteCommand(Extension.IEnsoService service, Command command) { Logging.AddActionLog(string.Format("TOpener: Executing command '{0}' ...", command.Name)); if (command.Name == "topen" || command.Name == "rtopen") { Logging.AddActionLog(string.Format("TOpener: Opening '{0}' in Total Commander ...", command.parametersOnExecute[0].GetValueAsText())); MessagesHandler.Display(string.Format("Opening {0} ...", command.parametersOnExecute[0].GetValueAsText())); if (IsPathSuitable(command.parametersOnExecute[0].GetValueAsText())) { TotalCommanderPane pane = TotalCommanderPane.Left; if (command.Name == "topen") { pane = TotalCommanderPane.Left; } else if (command.Name == "rtopen") { pane = TotalCommanderPane.Right; } OpenInTotalComander(command.parametersOnExecute[0].GetValueAsText(), pane); } else {//extract filepaths and try to open their parent folder List <string> fileSelectionList = Syntax.FileSelectionFromString(command.parametersOnExecute[0].GetValueAsText()); if (fileSelectionList.Count == 0) { Logging.AddErrorLog(string.Format("TOpener: File/Folder '{0}' not found.", command.parametersOnExecute[0].GetValueAsText())); MessagesHandler.Display("File/Folder not found.", command.parametersOnExecute[0].GetValueAsText()); } else { string parentFolder = Directory.GetParent(fileSelectionList[0]).FullName; if (IsPathSuitable(parentFolder)) { TotalCommanderPane pane = TotalCommanderPane.Left; if (command.Name == "topen") { pane = TotalCommanderPane.Left; } else if (command.Name == "rtopen") { pane = TotalCommanderPane.Right; } OpenInTotalComander(parentFolder, pane); } else { Logging.AddErrorLog(string.Format("TOpener: File/Folder '{0}' not found.", parentFolder)); MessagesHandler.Display("File/Folder not found.", parentFolder); } //foreach (string filePath in fileSelectionList) //{ // if (File.Exists(filePath) || Directory.Exists(filePath)) // { // OpenInTotalComander(filePath); // } // else // { // MessagesHandler.Display( "File/Folder not found.", filePath); // } //} } } } }
private void ProcessCommand(Object o) { KeyValuePair <IEnsoService, Command> parameters = (KeyValuePair <IEnsoService, Command>)o; IEnsoService service = parameters.Key; Command command = parameters.Value; if (command.parametersOnExecute[0] is ImageWorkItem) { string targetFilePath = null; try { SaveFileDialog saveFileDialog = new SaveFileDialog(); saveFileDialog.DefaultExt = ".png"; saveFileDialog.Filter = ".bmp|.bmp|.emf|.emf|.exif|.exif|.gif|.gif|.ico|.ico|.jpg|.jpg|.png|.png|.tif|.tif|.wmf|.wmf"; SetSaveFileDialogCommonOptions(saveFileDialog); Thread bringToFrontAssistant = new Thread(BringToFront); bringToFrontAssistant.Start(saveFileDialog.Title); if (saveFileDialog.ShowDialog() == DialogResult.OK) { Settings.Current.FileManagerSaveToDefaultFolder = Path.GetDirectoryName(saveFileDialog.FileName); targetFilePath = saveFileDialog.FileName; string targetExtension = Path.GetExtension(targetFilePath); ImageFormat targetImageFormat = ImageFormat.Png; if (string.Compare(targetExtension, ".bmp", true) == 0) { targetImageFormat = ImageFormat.Bmp; } else if (string.Compare(targetExtension, ".emf", true) == 0) { targetImageFormat = ImageFormat.Emf; } else if (string.Compare(targetExtension, ".exif", true) == 0) { targetImageFormat = ImageFormat.Exif; } else if (string.Compare(targetExtension, ".gif", true) == 0) { targetImageFormat = ImageFormat.Gif; } else if (string.Compare(targetExtension, ".ico", true) == 0) { targetImageFormat = ImageFormat.Icon; } else if (string.Compare(targetExtension, ".jpg", true) == 0) { targetImageFormat = ImageFormat.Jpeg; } else if (string.Compare(targetExtension, ".png", true) == 0) { targetImageFormat = ImageFormat.Png; } else if (string.Compare(targetExtension, ".tif", true) == 0) { targetImageFormat = ImageFormat.Tiff; } else if (string.Compare(targetExtension, ".wmf", true) == 0) { targetImageFormat = ImageFormat.Wmf; } ImageWorkItem imageWorkItem = (ImageWorkItem)command.parametersOnExecute[0]; imageWorkItem.image.Save(targetFilePath, targetImageFormat); Logging.AddActionLog(string.Format("FileManager: Image saved to '{0}'.", targetFilePath)); MessagesHandler.Display(string.Format("Saved.", command.Name)); if (command.Postfix == "[what] and copy its file path") { CraftSynth.BuildingBlocks.IO.Clipboard.SetTextToClipboard(targetFilePath); Logging.AddActionLog(string.Format("ClipboardManager: file path '{0}' copied to clipboard.", targetFilePath)); MessagesHandler.Display("Image saved and its file path copied."); } } } catch (Exception exception) { throw new ApplicationException(string.Format("FileManager: Failed to save image to '{0}'.", targetFilePath ?? "not set"), exception); } } else if ((command.parametersOnExecute[0] is Entities.StringWorkItem) || (command.parametersOnExecute[0] is Entities.Shortcut) || (command.parametersOnExecute[0] is Entities.Contact) || (command.parametersOnExecute[0] is Entities.CallerHistoryItem) || (command.parametersOnExecute[0] is Entities.MemorizedString)) { string targetFilePath = null; try { MessagesHandler.Display(command.parametersOnExecute[0].GetValueAsText()); SaveFileDialog saveFileDialog = new SaveFileDialog(); saveFileDialog.DefaultExt = ".txt"; saveFileDialog.Filter = ".txt|.txt"; SetSaveFileDialogCommonOptions(saveFileDialog); Thread bringToFrontAssistant = new Thread(BringToFront); bringToFrontAssistant.Start(saveFileDialog.Title); if (saveFileDialog.ShowDialog() == DialogResult.OK) { Settings.Current.FileManagerSaveToDefaultFolder = Path.GetDirectoryName(saveFileDialog.FileName); targetFilePath = saveFileDialog.FileName; File.WriteAllText(targetFilePath, command.parametersOnExecute[0].GetValueAsText()); Logging.AddActionLog(string.Format("FileManager: Text saved from work item to '{0}'.", targetFilePath)); MessagesHandler.Display(string.Format("Saved.", command.Name)); if (command.Postfix == "[what] and copy its file path") { CraftSynth.BuildingBlocks.IO.Clipboard.SetTextToClipboard(targetFilePath); Logging.AddActionLog(string.Format("ClipboardManager: file path '{0}' copied to clipboard.", targetFilePath)); MessagesHandler.Display("Text saved and its file path copied."); } } } catch (Exception exception) { throw new ApplicationException(string.Format("FileManager: Failed to save text from work item to '{0}'.", targetFilePath ?? "not set"), exception); } } else { Logging.AddErrorLog(string.Format("FileManager: Tried to save unsupported work item type.")); MessagesHandler.Display("Can not save work item of this type."); } }
private void Execute() { // get a manager for the scheduler YetaWFManager.MakeInitialThreadInstance(null); // TODO: Scheduler logging should not start during startup processing. This timer postpones it (but is not a good solution) // Because initialization is called during application startup, we'll wait before we // check for any scheduler items that may be due (just so app start isn't all too slow). try { Thread.Sleep(defaultStartupTimeSpan); } catch (ThreadInterruptedException) { // thread was interrupted because there is work to be done } SchedulerLog = new SchedulerLogging(); SchedulerLog.Init(); SchedulerLog.LimitTo(YetaWFManager.Manager); YetaWFManager.Syncify(async() => { // there is no point in running the scheduler async await Logging.RegisterLoggingAsync(SchedulerLog); }); Logging.AddTraceLog("Scheduler task started"); // mark all scheduled items that are supposed to be run at application startup try { YetaWFManager.Syncify(async() => { // there is no point in running the scheduler async await RunStartupItemsAsync(); }); } catch (Exception exc) { Logging.AddErrorLog("An error occurred running startup items", exc); } for (;;) { TimeSpan delayTime = defaultTimeSpanNoTask; if (SchedulerSupport.Enabled) { try { YetaWFManager.Syncify(async() => { // there is no point in running the scheduler async delayTime = await RunItemsAsync(); }); } catch (Exception exc) { delayTime = defaultTimeSpanError; Logging.AddErrorLog("An error occurred in the scheduling loop.", exc); } if (delayTime < new TimeSpan(0, 0, 5))// at a few seconds { delayTime = new TimeSpan(0, 0, 5); } else if (delayTime > new TimeSpan(1, 0, 0, 0)) // max. 1 day { delayTime = new TimeSpan(1, 0, 0, 0); } } try { schedulingThreadRunning = false; Logging.AddLog($"Waiting {delayTime}"); Thread.Sleep(delayTime); } catch (ThreadInterruptedException) { // thread was interrupted because there is work to be done } catch (ThreadAbortException) { } finally { schedulingThreadRunning = true; } } // This never really ends so we don't need to unregister logging //log.Shutdown(); //Logging.UnregisterLogging(log); }
private static void RdcOpenInNewThread(Command command) { Logging.AddActionLog(string.Format("RdcOpener: Opening '{0}' in RDC ...", command.parametersOnExecute[0].GetValueAsText().Trim().Split(' ')[0])); MessagesHandler.Display(string.Format("Connecting to {0} ...", command.parametersOnExecute[0].GetValueAsText().Trim().Split(' ')[0])); List <string> parts = command.parametersOnExecute[0].GetValueAsText(). Trim().Replace("\\r", " ").Replace("\\n", " "). Replace(" /user:"******" ").Replace(" /User:"******" ").Replace(" /USER:"******" "). Replace(" /pass:"******" ").Replace(" /Pass:"******" ").Replace(" /PASS:"******" "). Split(' ').ToList(); if (command.Name == "rdc-as-default-user" && parts.Count == 1) { //parts.RemoveAt(0);//as //parts.RemoveAt(0);//default //parts.RemoveAt(0);//user parts.Add(Settings.Current.RdcDefaultUsername); parts.Add(Settings.Current.RdcDefaultPassword); //final list should be ip,user1,pass1 } if (parts.Count == 1) { //example: 192.168.0.1:12 Process rdcProcess = new Process(); rdcProcess.StartInfo.FileName = Environment.ExpandEnvironmentVariables(@"%SystemRoot%\system32\mstsc.exe"); rdcProcess.StartInfo.Arguments = string.Format("/v {0}", parts[0]); rdcProcess.Start(); } else if (parts.Count == 2) { //example: 192.168.0.1:12 /user:mynet\Administrator Process rdcProcess = new Process(); rdcProcess.StartInfo.FileName = Environment.ExpandEnvironmentVariables(@"%SystemRoot%\system32\cmdkey.exe"); rdcProcess.StartInfo.Arguments = string.Format("/generic:TERMSRV/{0} /user:{1}", parts[0], parts[1]); rdcProcess.Start(); rdcProcess.StartInfo.FileName = Environment.ExpandEnvironmentVariables(@"%SystemRoot%\system32\mstsc.exe"); rdcProcess.StartInfo.Arguments = string.Format("/v {0}", parts[0]); rdcProcess.Start(); Thread.Sleep(10000); rdcProcess.StartInfo.FileName = Environment.ExpandEnvironmentVariables(@"%SystemRoot%\system32\cmdkey.exe"); rdcProcess.StartInfo.Arguments = string.Format("/delete:TERMSRV/{0}", parts[0]); rdcProcess.Start(); } else if (parts.Count == 3) { //example: 192.168.0.1:12 /user:mynet\Administrator /pass:somepass1 Process rdcProcess = new Process(); rdcProcess.StartInfo.FileName = Environment.ExpandEnvironmentVariables(@"%SystemRoot%\system32\cmdkey.exe"); rdcProcess.StartInfo.Arguments = string.Format("/generic:TERMSRV/{0} /user:{1} /pass:{2}", parts[0], parts[1], parts[2]); rdcProcess.Start(); rdcProcess.StartInfo.FileName = Environment.ExpandEnvironmentVariables(@"%SystemRoot%\system32\mstsc.exe"); rdcProcess.StartInfo.Arguments = string.Format("/v {0}", parts[0]); rdcProcess.Start(); Thread.Sleep(10000); rdcProcess.StartInfo.FileName = Environment.ExpandEnvironmentVariables(@"%SystemRoot%\system32\cmdkey.exe"); rdcProcess.StartInfo.Arguments = string.Format("/delete:TERMSRV/{0}", parts[0]); rdcProcess.Start(); } else { Logging.AddErrorLog(string.Format("RdcOpener: Invalid 'IP username password': '******'.", command.parametersOnExecute[0].GetValueAsText())); MessagesHandler.Display("Syntax 'IP:port username password' not recognized. Port, username and password are optional.", command.parametersOnExecute[0].GetValueAsText()); } }
private async Task RunItemAsync(SchedulerDataProvider schedDP, SchedulerItemData item) { long logId = DateTime.UtcNow.Ticks; SchedulerLog.SetCurrent(logId, 0, item.Name); item.IsRunning = true; item.RunTime = new TimeSpan(); item.Last = DateTime.UtcNow; try { await schedDP.UpdateItemAsync(item); } catch (Exception exc) { Logging.AddErrorLog("Updating scheduler item {0} failed.", item.Name, exc); } StringBuilder errors = new StringBuilder(); DateTime? nextRun = null;// called event handlers can return a next run time try { item.Errors = null; DateTime now = DateTime.UtcNow; { string m = $"Scheduler event - running scheduler item '{item.Name}'."; Logging.AddLog(m); errors.AppendLine(m); } Type tp = null; try { Assembly asm = Assemblies.Load(item.Event.ImplementingAssembly); tp = asm.GetType(item.Event.ImplementingType); } catch (Exception exc) { throw new InternalError("Scheduler item '{0}' could not be loaded (Type={1}, Assembly={2}) - {3}", item.Name, item.Event.ImplementingType, item.Event.ImplementingAssembly, ErrorHandling.FormatExceptionMessage(exc)); } if (item.SiteSpecific) { DataProviderGetRecords <SiteDefinition> info = await SiteDefinition.GetSitesAsync(0, 0, null, null); foreach (SiteDefinition site in info.Data) { IScheduling schedEvt = null; try { schedEvt = (IScheduling)Activator.CreateInstance(tp); } catch (Exception exc) { string m = $"Scheduler item '{item.Name}' could not be instantiated (Type={item.Event.ImplementingType}, Assembly={item.Event.ImplementingAssembly}) - {ErrorHandling.FormatExceptionMessage(exc)}"; Logging.AddLog(m); errors.AppendLine(m); } if (schedEvt != null) { YetaWFManager.MakeThreadInstance(site, null, true);// set up a manager for the site SchedulerLog.LimitTo(YetaWFManager.Manager); SchedulerLog.SetCurrent(logId, site.Identity, item.Name); SchedulerItemBase itemBase = new SchedulerItemBase { Name = item.Name, Description = item.Description, EventName = item.Event.Name, Enabled = true, Frequency = item.Frequency, Startup = item.Startup, SiteSpecific = true }; try { await schedEvt.RunItemAsync(itemBase); } catch (Exception exc) { string m = $"An error occurred in scheduler item '{site.Identity}: {item.Name}' - {ErrorHandling.FormatExceptionMessage(exc)}"; Logging.AddLog(m); errors.AppendLine(m); } foreach (var s in itemBase.Log) { string m = $"{site.Identity}: {s}"; Logging.AddLog(m); errors.AppendLine(m); } if (itemBase.NextRun != null && (nextRun == null || (DateTime)itemBase.NextRun < nextRun)) { nextRun = itemBase.NextRun; } YetaWFManager.RemoveThreadInstance(); YetaWFManager.MakeThreadInstance(null, null, true);// restore scheduler's manager SchedulerLog.LimitTo(YetaWFManager.Manager); SchedulerLog.SetCurrent(); } } } else { IScheduling schedEvt = null; try { schedEvt = (IScheduling)Activator.CreateInstance(tp); } catch (Exception exc) { string m = $"Scheduler item '{item.Name}' could not be instantiated (Type={item.Event.ImplementingType}, Assembly={item.Event.ImplementingAssembly}) - {ErrorHandling.FormatExceptionMessage(exc)}"; Logging.AddLog(m); errors.AppendLine(m); } if (schedEvt != null) { SchedulerItemBase itemBase = new SchedulerItemBase { Name = item.Name, Description = item.Description, EventName = item.Event.Name, Enabled = true, Frequency = item.Frequency, Startup = item.Startup, SiteSpecific = false }; try { await schedEvt.RunItemAsync(itemBase); } catch (Exception exc) { string m = $"An error occurred in scheduler item '{item.Name}' - {ErrorHandling.FormatExceptionMessage(exc)}"; Logging.AddLog(m); errors.AppendLine(m); } foreach (var s in itemBase.Log) { Logging.AddLog(s); errors.AppendLine(s); } if (itemBase.NextRun != null && (nextRun == null || (DateTime)itemBase.NextRun < nextRun)) { nextRun = itemBase.NextRun; } } } TimeSpan diff = DateTime.UtcNow - now; item.RunTime = diff; { string m = $"Elapsed time for scheduler item '{item.Name}' was {diff} (hh:mm:ss.ms)."; Logging.AddLog(m); errors.AppendLine(m); } } catch (Exception exc) { string m = $"Scheduler item {item.Name} failed - {ErrorHandling.FormatExceptionMessage(exc)}"; Logging.AddErrorLog(m); errors.AppendLine(m); } if (item.RunOnce) { item.Enabled = false; } item.IsRunning = false; item.SetNextRuntime(); if (nextRun != null) { Logging.AddLog($"Next run at {nextRun} (UTC)"); item.Next = nextRun; item.Enabled = true; } item.Errors = errors.ToString(); try { await schedDP.UpdateItemAsync(item); } catch (Exception exc) { string m = $"Updating scheduler item {item.Name} failed - {ErrorHandling.FormatExceptionMessage(exc)}"; Logging.AddErrorLog(m); errors.AppendLine(m); } SchedulerLog.SetCurrent(); }
private async Task <ActionResult> CompleteLoginAsync(LoginModel model, LoginConfigData config, bool useTwoStep) { Manager.SessionSettings.SiteSettings.ClearValue(LoginTwoStepController.IDENTITY_TWOSTEP_USERID); Manager.SessionSettings.SiteSettings.ClearValue(LoginTwoStepController.IDENTITY_TWOSTEP_NEXTURL); Manager.SessionSettings.SiteSettings.ClearValue(LoginTwoStepController.IDENTITY_TWOSTEP_CLOSEONLOGIN); Manager.SessionSettings.SiteSettings.Save(); model.Success = false; // make sure it's a valid user UserDefinition user = await Managers.GetUserManager().FindByNameAsync(model.UserName); if (user == null) { Logging.AddErrorLog("User login failed: {0} - no such user", model.UserName); ModelState.AddModelError(nameof(LoginModel.Email), this.__ResStr("invLogin", "Invalid user name or password")); ModelState.AddModelError(nameof(LoginModel.UserName), this.__ResStr("invLogin", "Invalid user name or password")); ModelState.AddModelError(nameof(LoginModel.Password), this.__ResStr("invLogin", "Invalid user name or password")); return(PartialView(model)); } using (UserLoginInfoDataProvider logInfoDP = new UserLoginInfoDataProvider()) { if (await logInfoDP.IsExternalUserAsync(user.UserId)) { throw new Error(this.__ResStr("extUser", "This account can only be accessed using an external login provider")); } } TwoStepAuth twoStep = new TwoStepAuth();// clear any two-step info we may have await twoStep.ClearTwoStepAutheticationAsync(user.UserId); if (config.MaxLoginFailures != 0 && user.LoginFailures >= config.MaxLoginFailures) { ModelState.AddModelError(nameof(LoginModel.Email), this.__ResStr("maxAttemps", "The maximum number of login attempts has been exceeded - Your account has been suspended")); ModelState.AddModelError(nameof(LoginModel.UserName), this.__ResStr("maxAttemps", "The maximum number of login attempts has been exceeded - Your account has been suspended")); if (user.UserStatus != UserStatusEnum.Suspended) { user.UserStatus = UserStatusEnum.Suspended; await Managers.GetUserManager().UpdateAsync(user); } return(PartialView(model)); } UserDefinition foundUser = user; user = null; // Handle random super user password (only supported on Core) if (foundUser.UserId == SuperuserDefinitionDataProvider.SuperUserId && SuperuserDefinitionDataProvider.SuperuserAvailable && SuperuserDefinitionDataProvider.SuperUserPasswordRandom && model.UserName == SuperuserDefinitionDataProvider.SuperUserName && model.Password == SuperuserDefinitionDataProvider.SuperUserPassword) { user = foundUser; } if (user == null) { user = await Managers.GetUserManager().FindByNameAsync(model.UserName); if (string.IsNullOrWhiteSpace(model.Password) || !await Managers.GetUserManager().CheckPasswordAsync(user, model.Password)) { user = null; } } if (user == null) { foundUser.LoginFailures = foundUser.LoginFailures + 1; await Managers.GetUserManager().UpdateAsync(foundUser); Logging.AddErrorLog("User login failed: {0}, {1}, {2}", model.UserName, model.Password, model.VerificationCode); ModelState.AddModelError(nameof(LoginModel.Email), this.__ResStr("invLogin", "Invalid user name or password")); ModelState.AddModelError(nameof(LoginModel.UserName), this.__ResStr("invLogin", "Invalid user name or password")); ModelState.AddModelError(nameof(LoginModel.Password), this.__ResStr("invLogin", "Invalid user name or password")); return(PartialView(model)); } // if verification code valid, advance user to approved or needs approval if (user.UserStatus == UserStatusEnum.NeedValidation && model.VerificationCode == user.VerificationCode) { Logging.AddLog("User {0} validated ({1})", model.UserName, model.VerificationCode); if (config.ApproveNewUsers) { user.UserStatus = UserStatusEnum.NeedApproval; user.LastActivityDate = DateTime.UtcNow; user.LastActivityIP = Manager.UserHostAddress; await Managers.GetUserManager().UpdateAsync(user); Emails emails = new Emails(); await emails.SendApprovalNeededAsync(user); string nextPage = string.IsNullOrWhiteSpace(config.ApprovalPendingUrl) ? Manager.CurrentSite.HomePageUrl : config.ApprovalPendingUrl; return(FormProcessed(model, this.__ResStr("notApproved", "You just verified your account. Now your account has to be approved by the site administrator. You will receive an email confirmation as soon as your account is active."), NextPage: nextPage)); } user.UserStatus = UserStatusEnum.Approved; // this is saved below, before we're logged in } // check what to do based on account status if (user.UserStatus == UserStatusEnum.NeedValidation) { if (model.ShowVerification) { Logging.AddErrorLog("User {0} - invalid verification code({1})", model.UserName, model.VerificationCode); ModelState.AddModelError(nameof(LoginModel.VerificationCode), this.__ResStr("invVerification", "The verification code is invalid. Please make sure to copy/paste it from the email to avoid any typos.")); user.LoginFailures = user.LoginFailures + 1; await Managers.GetUserManager().UpdateAsync(user); } else { ModelState.AddModelError(nameof(LoginModel.VerificationCode), this.__ResStr("notValidated", "Your account has not yet been verified. You will receive an email with verification information. Please copy and enter the verification code here.")); } model.ShowVerification = true; model.ResendVerificationCode = await Module.GetAction_ResendVerificationEmailAsync(user.UserName); model.ShowCaptcha = false; return(PartialView(model)); } else if (user.UserStatus == UserStatusEnum.NeedApproval) { Logging.AddErrorLog("User {0} - not yet approved", model.UserName); string nextPage = string.IsNullOrWhiteSpace(config.ApprovalPendingUrl) ? Manager.CurrentSite.HomePageUrl : config.ApprovalPendingUrl; return(FormProcessed(model, this.__ResStr("notApproved2", "Your account has not yet been approved by the site administrator. You will receive an email confirmation as soon as your account is active."), NextPage: nextPage)); } else if (user.UserStatus == UserStatusEnum.Rejected) { Logging.AddErrorLog("User {0} - rejected user", model.UserName); string nextPage = string.IsNullOrWhiteSpace(config.RejectedUrl) ? Manager.CurrentSite.HomePageUrl : config.RejectedUrl; return(FormProcessed(model, this.__ResStr("accountRejected", "Your account has been rejected by the site administrator."), NextPage: nextPage)); } else if (user.UserStatus == UserStatusEnum.Suspended) { Logging.AddErrorLog("User {0} - suspended user", model.UserName); string nextPage = string.IsNullOrWhiteSpace(config.SuspendedUrl) ? Manager.CurrentSite.HomePageUrl : config.SuspendedUrl; return(FormProcessed(model, this.__ResStr("accountSuspended", "Your account has been suspended."), NextPage: nextPage)); } else if (user.UserStatus == UserStatusEnum.Approved) { string nextUrl = null; if (Manager.HaveReturnToUrl) { nextUrl = Manager.ReturnToUrl; } if (string.IsNullOrWhiteSpace(nextUrl)) { nextUrl = await Resource.ResourceAccess.GetUserPostLoginUrlAsync((from u in user.RolesList select u.RoleId).ToList()); } if (string.IsNullOrWhiteSpace(nextUrl)) { nextUrl = Manager.CurrentSite.PostLoginUrl; } if (string.IsNullOrWhiteSpace(nextUrl)) { nextUrl = YetaWFManager.Manager.CurrentSite.HomePageUrl; } if (useTwoStep) { ActionResult actionResult = await TwoStepAuthetication(user); if (actionResult != null) { Manager.SessionSettings.SiteSettings.SetValue <int>(LoginTwoStepController.IDENTITY_TWOSTEP_USERID, user.UserId);// marker that user has entered correct name/password Manager.SessionSettings.SiteSettings.SetValue <string>(LoginTwoStepController.IDENTITY_TWOSTEP_NEXTURL, nextUrl); Manager.SessionSettings.SiteSettings.SetValue <bool>(LoginTwoStepController.IDENTITY_TWOSTEP_CLOSEONLOGIN, model.CloseOnLogin); Manager.SessionSettings.SiteSettings.Save(); return(actionResult); } } await LoginModuleController.UserLoginAsync(user, model.RememberMe); model.Success = true; Logging.AddLog("User {0} - logged on", model.UserName); return(FormProcessed(model, OnClose: OnCloseEnum.GotoNewPage, OnPopupClose: OnPopupCloseEnum.GotoNewPage, NextPage: nextUrl, ForceRedirect: true)); } else { throw new InternalError("badUserStatus", "Unexpected account status {0}", user.UserStatus); } }