/// <summary> /// Gets and bulk updates eventss. Called when the "Get and bulk update events" button is pressed. /// Expects the LogEvent method to be run first. /// </summary> private bool GetAndBulkUpdateEvents() { // Create new instance of event log provider EventLogProvider eventLog = new EventLogProvider(); // Get events matching the where condition string where = "EventCode = 'APIEXAMPLE'"; DataSet events = eventLog.GetAllEvents(where, null); if (!DataHelper.DataSourceIsEmpty(events)) { // Loop through the individual items foreach (DataRow eventDr in events.Tables[0].Rows) { // Create the object from DataRow EventLogInfo updateEvent = new EventLogInfo(eventDr); // Update the properties updateEvent.EventDescription = updateEvent.EventDescription.ToUpper(); // Save the changes eventLog.SetEventLogInfo(updateEvent); } return true; } return false; }
/// <summary> /// Executes the task. /// </summary> /// <param name="ti">Task info</param> public string Execute(TaskInfo ti) { EventLogProvider ev = new EventLogProvider(); ev.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, "MyTask", "Execute", null, "This task was executed from '~/App_Code/Global/CMS/CMSCustom.cs'."); return null; }
protected void btnClone_Click(object sender, EventArgs e) { try { CloneResult result = cloneObjectElem.CloneObject(); if (result != null) { if (result.Errors.Count > 0) { ShowError(ResHelper.LocalizeString(string.Join("\n", result.Errors.ToArray()))); SwitchToErrorMode(); } else if (result.Warnings.Count > 0) { ShowWarning(GetString("cloning.savedwithwarnings"), ResHelper.LocalizeString(string.Join("<br/>", result.Warnings.ToArray())), null); SwitchToErrorMode(); } else { ScriptHelper.RegisterStartupScript(this.Page, typeof(string), "CloneRefresh", cloneObjectElem.CloseScript, true); } } } catch (Exception ex) { EventLogProvider provider = new EventLogProvider(); provider.LogEvent(string.IsNullOrEmpty(objectType) ? "System" : objectType.ToLowerCSafe(), "CLONEOBJECT", ex); ShowError(ex.Message); if (!cloneObjectElem.UseTransaction) { SwitchToErrorMode(); } } }
/// <summary> /// Sets the specified site data. /// </summary> /// <param name="siteInfoObj">New site info data</param> protected override void SetSiteInfoInternal(SiteInfo siteInfoObj) { base.SetSiteInfoInternal(siteInfoObj); // Log the event that the site was updated EventLogProvider ev = new EventLogProvider(); ev.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, "MyCustomSiteInfoProvider", "SetSiteInfo", null, "The site was updated"); }
/// <summary> /// Removes the item from the cache. /// </summary> /// <param name="key">Cache key</param> protected override object RemoveInternal(string key) { // Log the event that the user was updated EventLogProvider ev = new EventLogProvider(); ev.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, "MyCustomCacheHelper", "Remove", null, "The cache item was removed"); return base.RemoveInternal(key); }
/// <summary> /// Clears event log for current site. Called when the "Clear event log" button is pressed. /// Expects the CreateAbuseReport method to be run first. /// </summary> private bool ClearLog() { // Create new instance of event log provider EventLogProvider eventLog = new EventLogProvider(); // Clear event log for current site eventLog.ClearEventLog(CMSContext.CurrentUser.UserID, CMSContext.CurrentUser.UserName, HTTPHelper.UserHostAddress, CMSContext.CurrentSiteID); return true; }
/// <summary> /// OkClick Handler. /// </summary> protected void btnOk_Click(object sender, EventArgs e) { string culture = ValidationHelper.GetString(cultureSelector.Value, ""); if ((culture != "") && ((currentCulture.ToLower() != culture.ToLower()) || chkDocuments.Checked)) { // Set new culture SiteInfo si = SiteInfoProvider.GetSiteInfo(siteId); if (si != null) { try { // Set default culture and change current culture label ObjectHelper.SetSettingsKeyValue(si.SiteName + ".CMSDefaultCultureCode", culture.Trim()); // Change culture of documents if (chkDocuments.Checked) { // Change culture of the documents TreeProvider tree = new TreeProvider(CMSContext.CurrentUser); tree.ChangeCulture(si.SiteName, currentCulture, culture); } if (!LicenseHelper.CheckFeature(URLHelper.GetCurrentDomain(), FeatureEnum.Multilingual)) { // If not multilingual, remove all cultures from the site and assign new culture CultureInfoProvider.RemoveSiteCultures(si.SiteName); CultureInfoProvider.AddCultureToSite(culture, si.SiteName); } ltlScript.Text = ScriptHelper.GetScript("wopener.ChangeCulture('" + chkDocuments.Checked.ToString() + "'); window.close();"); } catch (Exception ex) { EventLogProvider ev = new EventLogProvider(); ev.LogEvent("SiteManager", "ChangeDefaultCulture", ex); } } } else { ltlScript.Text = ScriptHelper.GetScript("window.close();"); } }
/// <summary> /// Logs error. /// </summary> /// <param name="message">Error message</param> /// <param name="eventCode">Event code</param> protected void LogEvent(string message, string eventCode) { try { // Add some additional information to the error message string info = "ORDER ID: " + orderId + "\r\n"; info += "TRANSACTION ID: " + transactionId + "\r\n"; info += "PAYMENT STATUS: " + paymentStatus + "\r\n"; message = info + message; EventLogProvider evenLog = new EventLogProvider(); evenLog.LogEvent(EventLogProvider.EVENT_TYPE_ERROR, DateTime.Now, "PayPal IPN", eventCode, 0, "", 0, "", "", message, 0, ""); } catch { // Unable to log the event } }
/// <summary> /// Generates sample data. /// </summary> private void GenerateData() { try { QueryDataParameters parameters = new QueryDataParameters(); parameters.Add("siteId", CMSContext.CurrentSiteID); ConnectionHelper.ExecuteQuery("ecommerce.order.generateSampleData", parameters); // Log successful attempt EventLogProvider eventLog = new EventLogProvider(); eventLog.LogEvent("I", DateTime.Now, "E-commerce data generator", "DATAGENERATED", CMSContext.CurrentSiteID); ShowConfirmation(GetString("com.reports.datagenerated")); } catch (Exception ex) { EventLogProvider.LogException("Reports", "Generate", ex); ShowError(GetString("com.reports.operationFailed")); } }
protected void btnHiddenImpersonate_Click(object sender, EventArgs e) { string originalUserName = ValidationHelper.GetString(SessionHelper.GetValue("OriginalUserName"), ""); if (RequestHelper.IsFormsAuthentication()) { UserInfo ui = UserInfoProvider.GetUserInfo(originalUserName); CMSContext.CurrentUser.UserImpersonate(ui); } else { SessionHelper.SetValue("ImpersonateUserName", null); SessionHelper.SetValue("OriginalUserName", null); CMSContext.CurrentUser.Invalidate(false); // Log event EventLogProvider log = new EventLogProvider(); log.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, "Administration", "Impersonate", 0, null, 0, null, null, "User " + originalUserName + " has returned to his account.", CMSContext.CurrentSiteID, URLHelper.CurrentURL); URLHelper.Redirect(URLHelper.CurrentURL); } }
protected void Page_Load(object sender, EventArgs e) { string domain = QueryHelper.GetText("domainname", String.Empty); if (domain != String.Empty) { LicenseKeyInfo lki = LicenseKeyInfoProvider.GetLicenseKeyInfo(domain); if (lki != null) { LabelMessage.Text = GetString("CMSSiteManager.FeatureNotAvailable"); // Log message to event log EventLogProvider eventLog = new EventLogProvider(); eventLog.LogEvent(EventLogProvider.EVENT_TYPE_WARNING, DateTime.Now, "Feature not available page", "FeatureNotAvailable", URLHelper.CurrentURL, "The requested feature is not available in the CMS edition you are using: " + LicenseHelper.GetEditionName(lki.Edition)); } else { LabelMessage.Text = GetString("CMSSiteManager.LicenseNotFound").Replace("%%name%%", domain); } } titleElem.TitleText = GetString("CMSSiteManager.AccesDenied"); titleElem.TitleImage = GetImageUrl("Others/Messages/denied.png"); }
private string BuildStartupScript() { bool enBBCode = IsSupport || (ChatHelper.EnableBBCodeSetting && EnableBBCode); WebControl input = enBBCode ? ucBBEditor.TextArea : txtMessage; if (enBBCode) { txtMessage.Visible = false; } else { ucBBEditor.Visible = false; } JavaScriptSerializer sr = new JavaScriptSerializer(); string json = sr.Serialize( new { roomID = RoomID, inputClientID = GetString(input), buttonClientID = GetString(btnSendMessage), groupID = GroupID, chbWhisperClientID = GetString(chbWhisper), drpRecipientClientID = GetString(drpRecipient), noneLabel = ResHelper.GetString("chat.everyone"), enableBBCode = enBBCode, bbCodeClientID = GetString(ucBBEditor), btnCannedResponses = GetString(btnCannedResponses), pnlContent = GetString(pnlWebpartContent), envelopeID = "#envelope_" + ClientID, informDialogID = GetString(pnlChatMessageSendInfoDialog), btnInformDialogClose = GetString(btnChatMessageSendInformDialogClose) } ); string startupScript = String.Format("InitChatSenderWebpart({0});", json); // If this webpart is for support person -> generate "Canned responses" if ((ChatOnlineUserHelper.GetLoggedInChatUser() != null) && (IsSupport == true)) { // Get canned responses from database IEnumerable <ChatSupportCannedResponseInfo> cannedResponses = ChatSupportCannedResponseInfoProvider.GetCannedResponses(ChatOnlineUserHelper.GetLoggedInChatUser().ChatUserID, CMSContext.CurrentSiteID); if (cannedResponses.Count() > 0) { btnCannedResponses.Visible = true; // Register necessary files ScriptHelper.RegisterScriptFile(Page, "~/CMSWebParts/Chat/ChatMessageSend_files/CannedResponses.js"); CSSHelper.RegisterCSSLink(Page, "~/App_Themes/Design/Chat/ChatIntelliSense.css"); // Creates canned responses in format expected in javascript var cannedResponseToSerialize = from cr in cannedResponses let resolvedText = CMSContext.ResolveMacros(cr.ChatSupportCannedResponseText) select new { label = "#" + cr.ChatSupportCannedResponseTagName, tooltip = TextHelper.LimitLength(resolvedText, mTooltipLength), value = resolvedText }; // Serialize canned responses to JS Array expected by javascript string cannedResponsesJSArray = ""; try { cannedResponsesJSArray = sr.Serialize(cannedResponseToSerialize); } catch (Exception ex) { EventLogProvider.LogException("Chat", "JSON serialization of canned responses", ex); } startupScript += string.Format("var CannedResponses = {0};", cannedResponsesJSArray); startupScript += string.Format("InitCannedResponses({0}, {1});", ScriptHelper.GetString("#" + input.ClientID), ScriptHelper.GetString("#" + btnCannedResponses.ClientID)); } } return(startupScript); }
/// <summary> /// Saves the item /// </summary> /// <param name="saveAndClose">Close dialog after save</param> private void Save(bool saveAndClose) { //Check valid input string errMsg = new Validator(). NotEmpty(txtName.Text, GetString("img.errors.filename")). IsFolderName(txtName.Text, GetString("img.errors.filename")). Result; if (!String.IsNullOrEmpty(errMsg)) { ShowError(errMsg); return; } // Prepare the path string path = filePath; if (!newFile) { path = Path.GetDirectoryName(path); } path += "\\" + txtName.Text + extension; // Check the file name for existence if (!txtName.Text.EqualsCSafe(fileName, true)) { if (File.Exists(path)) { errMsg = GetString("general.fileexists"); } } if (!String.IsNullOrEmpty(errMsg)) { ShowError(errMsg); return; } bool success = true; bool fileNameChanged = false; try { // Move the file to the new location if (!newFile && !path.EqualsCSafe(filePath, true)) { File.WriteAllText(filePath, txtContent.Text); File.Move(filePath, path); fileNameChanged = true; } // Create the file or write into it else { File.WriteAllText(path, txtContent.Text); } } catch (Exception ex) { success = false; ShowError(GetString("general.saveerror"), ex.Message, null); EventLogProvider.LogException("FileSystemSelector", "SAVEFILE", ex); } if (success) { ShowChangesSaved(); // Redirect for new items if (newFile && !saveAndClose) { string fileIdentifier = Guid.NewGuid().ToString("N") + path.GetHashCode(); Hashtable pp = new Hashtable(); pp.Add("filepath", URLHelper.UnMapPath(path)); pp.Add("newfileextension", String.Empty); WindowHelper.Add(fileIdentifier, pp); string parameters = String.Format("?identifier={0}&saved=1", fileIdentifier); string validationHash = QueryHelper.GetHash(parameters); string url = UrlResolver.ResolveUrl("~/CMSModules/Content/Controls/Dialogs/Selectors/FileSystemSelector/EditTextFile.aspx") + parameters + "&hash=" + validationHash; URLHelper.Redirect(url); } // Update file name path stored in session in case of changing file name if (fileNameChanged) { prop["filepath"] = URLHelper.UnMapPath(path); WindowHelper.Add(identifier, prop); } String script = "wopener.SetRefreshAction();"; if (saveAndClose) { script += "CloseDialog()"; } ScriptHelper.RegisterStartupScript(Page, typeof(String), "closescript", ScriptHelper.GetScript(script)); RegisterRefreshScript(); } }
/// <summary> /// Reload data. /// </summary> public override void ReloadData() { try { treeElem.Nodes.Clear(); // Get root files string rootDir = RootFolderPath; if (rootDir != null) { rootDir = rootDir.TrimEnd('\\'); } if (!String.IsNullOrEmpty(MediaLibraryPath)) { rootDir = DirectoryHelper.CombinePath(rootDir, MediaLibraryPath); } else if (!String.IsNullOrEmpty(MediaLibraryFolder)) { rootDir = DirectoryHelper.CombinePath(rootDir, MediaLibraryFolder); } // Get the file and directories count int dirCount = 0; string[] directories = null; if (rootDir != null) { if (!Directory.Exists(rootDir)) { DirectoryHelper.EnsureDiskPath(Path.EnsureEndBackslash(rootDir), Server.MapPath("~")); } directories = Directory.GetDirectories(rootDir); } if (directories != null) { // Each directory contains directory for thumbnails dirCount = directories.Length - 1; } // Create root tree node TreeNode root; if (DisplayFilesCount) { int fileCount = 0; string[] files = Directory.GetFiles(rootDir); if (files != null) { fileCount = files.Length; } root = CreateNode("<span class=\"Name\">" + MediaLibraryFolder + " (" + fileCount + ")</span>", MediaLibraryFolder, null, dirCount, 0); } else { root = CreateNode("<span class=\"Name\">" + MediaLibraryFolder + "</span>", MediaLibraryFolder, null, dirCount, 0); } // Keep root expanded root.Expand(); // Add root node treeElem.Nodes.Add(root); if (!StopProcessing) { // Bind tree nodes if (String.IsNullOrEmpty(MediaLibraryPath)) { BindTreeView(RootFolderPath + MediaLibraryFolder, root, true); } else { BindTreeView(DirectoryHelper.CombinePath(RootFolderPath, MediaLibraryPath), root, true); } } ScriptHelper.RegisterStartupScript(Page, typeof(Page), "RemoveMultipleNodes_" + ClientID, ScriptHelper.GetScript("if (typeof(ResolveDuplicateNodes) != 'undefined') { ResolveDuplicateNodes('" + treeElem.ClientID + "') }")); } catch (Exception ex) { // Set error message lblError.Text = GetString("FolderTree.FailedLoad") + ": " + ex.Message; lblError.ToolTip = EventLogProvider.GetExceptionLogMessage(ex); } finally { // Check for root node RootNodeLoaded = (treeElem.Nodes.Count > 0); } }
/// <summary> /// Generates variants asynchronous. /// </summary> /// <param name="parameter">AsyncControl parameters</param> private void GenerateAndSave(object parameter) { try { // Regenerate already existing variants if (mRegenerateVariants) { ProductAttributeSet productAttributeSet = new ProductAttributeSet(CategorySelector.SelectedCategories.Values.Where(x => x > VariantOptionInfo.NewOption)); List <ProductVariant> existingVariants = VariantHelper.AddNewCategoriesToVariantsOfProduct(ProductID, productAttributeSet); // Use special action contexts to turn off unnecessary actions using (ECommerceActionContext eCommerceContext = new ECommerceActionContext()) { eCommerceContext.TouchParent = false; eCommerceContext.SetLowestPriceToParent = false; eCommerceContext.AssignDefaultTaxesToProducts = false; existingVariants.ForEach(pVariant => { AddLog(HTMLHelper.HTMLEncode(ResHelper.LocalizeString(pVariant.Variant.SKUName)) + GetString("com.variants.isredefined")); VariantHelper.SetProductVariant(pVariant); }); } // Save variant to update parent SKULastModified a SKUPrice properties var lastVariant = existingVariants.LastOrDefault(); if (lastVariant != null) { lastVariant.Variant.Generalized.SetObject(); } } // Generate non-existing variants ProductVariant productVariant = null; // Use special action contexts to turn off unnecessary actions using (ECommerceActionContext eCommerceContext = new ECommerceActionContext()) { eCommerceContext.TouchParent = false; eCommerceContext.SetLowestPriceToParent = false; eCommerceContext.AssignDefaultTaxesToProducts = false; foreach (DataRow row in mVariantsToGenerate) { IEnumerable <int> options = GetAllOptions(row, NewCategories.Union(ExistingCategories)); productVariant = new ProductVariant(ProductID, new ProductAttributeSet(options)); AddLog(HTMLHelper.HTMLEncode(ResHelper.LocalizeString(productVariant.Variant.SKUName)) + GetString("com.variants.isdefined")); productVariant.Set(); } } // Save variant to update parent SKULastModified a SKUPrice properties if (productVariant != null) { productVariant.Variant.Generalized.SetObject(); } } catch (Exception ex) { CurrentError = GetString("com.variant.definerror"); EventLogProvider.LogException("Variant definition", "DEFINEVARIANT", ex); } }
private static void Upgrade60Import() { EventLogProvider evp = new EventLogProvider(); // Import try { RequestStockHelper.Remove("CurrentDomain", true); SiteImportSettings importSettings = new SiteImportSettings(CMSContext.CurrentUser) { DefaultProcessObjectType = ProcessObjectEnum.All, SourceFilePath = mUpgradePackagePath, WebsitePath = mWebsitePath }; ImportProvider.ImportObjectsData(importSettings); // Regenerate time zones TimeZoneInfoProvider.GenerateTimeZoneRules(); #region "Separability" String webPartsPath = mWebsitePath + "CMSWebParts\\"; List<String> files = new List<string>(); // Create list of files to remove if (!ModuleEntry.IsModuleLoaded(ModuleEntry.BIZFORM)) { files.AddRange(GetAllFiles(webPartsPath + "BizForms")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.BLOGS)) { files.AddRange(GetAllFiles(webPartsPath + "Blogs")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.COMMUNITY)) { files.AddRange(GetAllFiles(webPartsPath + "Community")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.ECOMMERCE)) { files.AddRange(GetAllFiles(webPartsPath + "Ecommerce")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.EVENTMANAGER)) { files.AddRange(GetAllFiles(webPartsPath + "Events")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.FORUMS)) { files.AddRange(GetAllFiles(webPartsPath + "Forums")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.MEDIALIBRARY)) { files.AddRange(GetAllFiles(webPartsPath + "MediaLibrary")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.MESSAGEBOARD)) { files.AddRange(GetAllFiles(webPartsPath + "MessageBoards")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.MESSAGING)) { files.AddRange(GetAllFiles(webPartsPath + "Messaging")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.NEWSLETTER)) { files.AddRange(GetAllFiles(webPartsPath + "Newsletters")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.NOTIFICATIONS)) { files.AddRange(GetAllFiles(webPartsPath + "Notifications")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.ONLINEMARKETING)) { files.AddRange(GetAllFiles(webPartsPath + "OnlineMarketing")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.POLLS)) { files.AddRange(GetAllFiles(webPartsPath + "Polls")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.PROJECTMANAGEMENT)) { files.AddRange(GetAllFiles(webPartsPath + "ProjectManagement")); } if (!ModuleEntry.IsModuleLoaded(ModuleEntry.REPORTING)) { files.AddRange(GetAllFiles(webPartsPath + "Reporting")); } // Remove webparts for separated modules foreach (String file in files) { try { File.Delete(file); } catch (Exception ex) { evp.LogEvent("Upgrade to 6.0", "Upgrade", ex); } } #endregion evp.LogEvent("I", DateTime.Now, "Upgrade to 6.0", "Upgrade - Finish"); } catch (Exception ex) { evp.LogEvent("Upgrade to 6.0", "Upgrade", ex); } }
/// <summary> /// When exception occurs, log it to event log. /// </summary> /// <param name="ex">Exception to log</param> private void LogExceptionToEventLog(Exception ex) { EventLogProvider log = new EventLogProvider(); log.LogEvent(EventLogProvider.EVENT_TYPE_ERROR, DateTime.Now, "Content", "IMPORTFILE", CMSContext.CurrentUser.UserID, CMSContext.CurrentUser.UserName, 0, null, HTTPHelper.UserHostAddress, EventLogProvider.GetExceptionLogMessage(ex), CMSContext.CurrentSiteID, HTTPHelper.GetAbsoluteUri()); AddError(GetString("tools.fileimport.failed") + " (" + ex.Message + ")"); }
/// <summary> /// Yes button click event handler. /// </summary> protected void btnYes_Click(object sender, EventArgs e) { if (IsBannedIP()) { return; } // Prepare the where condition string where = "NodeID = " + NodeID; // Get the documents DataSet ds = null; if (chkAllCultures.Checked) { ds = TreeProvider.SelectNodes(SiteName, "/%", TreeProvider.ALL_CULTURES, true, null, where, null, -1, false); } else { ds = TreeProvider.SelectNodes(SiteName, "/%", CultureCode, false, null, where, null, -1, false); } if (!DataHelper.DataSourceIsEmpty(ds)) { // Get node alias var nodeAlias = DataHelper.GetStringValue(ds.Tables[0].Rows[0], "NodeAlias", string.Empty); // Get parent alias path var parentAliasPath = TreePathUtils.GetParentPath(DataHelper.GetStringValue(ds.Tables[0].Rows[0], "NodeAliasPath", string.Empty)); // Delete the documents foreach (DataRow dr in ds.Tables[0].Rows) { var aliasPath = ValidationHelper.GetString(dr["NodeAliasPath"], string.Empty); var culture = ValidationHelper.GetString(dr["DocumentCulture"], string.Empty); var className = ValidationHelper.GetString(dr["ClassName"], string.Empty); // Get the node var treeNode = TreeProvider.SelectSingleNode(SiteName, aliasPath, culture, false, className, false); if (treeNode != null) { // Check delete permissions var hasUserDeletePermission = !CheckPermissions || IsUserAuthorizedToDeleteDocument(treeNode, chkDestroy.Checked); if (hasUserDeletePermission) { // Delete the document try { LogDeleteActivity(treeNode); DocumentHelper.DeleteDocument(treeNode, TreeProvider, chkAllCultures.Checked, chkDestroy.Checked); } catch (Exception ex) { EventLogProvider.LogEvent(EventType.ERROR, "Content", "DELETEDOC", EventLogProvider.GetExceptionLogMessage(ex), RequestContext.RawURL, MembershipContext.AuthenticatedUser.UserID, MembershipContext.AuthenticatedUser.UserName, treeNode.NodeID, treeNode.GetDocumentName(), RequestContext.UserHostAddress, SiteContext.CurrentSiteID); AddAlert(GetString("ContentRequest.DeleteFailed") + ": " + ex.Message); return; } } // Access denied - not authorized to delete the document else { AddAlert(String.Format(GetString("cmsdesk.notauthorizedtodeletedocument"), treeNode.NodeAliasPath)); return; } } else { AddAlert(GetString("ContentRequest.ErrorMissingSource")); return; } } RaiseOnAfterDelete(); string rawUrl = RequestContext.RawURL.TrimEnd(new[] { '/' }); if ((!string.IsNullOrEmpty(nodeAlias)) && (rawUrl.Substring(rawUrl.LastIndexOfCSafe('/')).Contains(nodeAlias))) { // Redirect to the parent url when current url belongs to deleted document URLHelper.Redirect(DocumentURLProvider.GetUrl(parentAliasPath)); } else { // Redirect to current url URLHelper.Redirect(rawUrl); } } else { AddAlert(GetString("DeleteDocument.CultureNotExists")); } }
/// <summary> /// Callback event handler. /// </summary> /// <param name="argument">Callback argument</param> public void RaiseCallbackEvent(string argument) { // Get arguments string[] args = argument.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); bool cancel = ValidationHelper.GetBoolean(args[0], false); int messageLength = 0; int errorLength = 0; int warningLength = 0; string machineName = null; if (args.Length == 5) { messageLength = ValidationHelper.GetInteger(args[1], 0); errorLength = ValidationHelper.GetInteger(args[2], 0); warningLength = ValidationHelper.GetInteger(args[3], 0); machineName = ValidationHelper.GetString(args[4], null); } // Check if on same machine if (machineName == SqlHelperClass.MachineName.ToLowerCSafe()) { try { // Cancel Import if (cancel) { ImportManager.Settings.Cancel(); } hdnState.Value = ImportManager.Settings.GetLimitedProgressLog(messageLength, errorLength, warningLength); } catch (Exception ex) { EventLogProvider ev = new EventLogProvider(); ev.LogEvent("NewSiteWizard", "IMPORT", ex); hdnState.Value = ImportManager.Settings.GetLimitedProgressLog(messageLength, errorLength, warningLength); } finally { if (ImportManager.Settings.GetProgressState() != LogStatusEnum.Info) { // Delete presistent data PersistentStorageHelper.RemoveValue(PersistentSettingsKey); } } } }
private void HandleError(Exception exception) { SalesForceError.Report(exception); EventLogProvider.LogException("Salesforce.com Connector", "MappingEditorPage", exception); }
/// <summary> /// Saves order information from ShoppingCartInfo object to database as new order. /// </summary> public override bool ProcessStep() { // Load first step if there is no address if (ShoppingCart.ShoppingCartBillingAddressID <= 0) { ShoppingCartControl.LoadStep(0); return(false); } // Check if customer is enabled if ((ShoppingCart.Customer != null) && (!ShoppingCart.Customer.CustomerEnabled)) { lblError.Text = GetString("ecommerce.cartcontent.customerdisabled"); return(false); } // Deal with order note ShoppingCartControl.SetTempValue(ORDER_NOTE, null); ShoppingCart.ShoppingCartNote = txtNote.Text.Trim(); try { // Set order culture ShoppingCart.ShoppingCartCulture = LocalizationContext.PreferredCultureCode; // Update customer preferences CustomerInfoProvider.SetCustomerPreferredSettings(ShoppingCart); // Create order ShoppingCartInfoProvider.SetOrder(ShoppingCart); } catch (Exception ex) { // Show error lblError.Text = GetString("Ecommerce.OrderPreview.ErrorOrderSave"); // Log exception EventLogProvider.LogException("Shopping cart", "SAVEORDER", ex, ShoppingCart.ShoppingCartSiteID, null); return(false); } // Track order items conversions ECommerceHelper.TrackOrderItemsConversions(ShoppingCart); // Track order conversion string name = ShoppingCartControl.OrderTrackConversionName; ECommerceHelper.TrackOrderConversion(ShoppingCart, name); // Track order activity string siteName = SiteContext.CurrentSiteName; if (LogActivityForCustomer) { ShoppingCartControl.TrackActivityPurchasedProducts(ShoppingCart, siteName, ContactID); ShoppingCartControl.TrackActivityPurchase(ShoppingCart.OrderId, ContactID, SiteContext.CurrentSiteName, RequestContext.CurrentRelativePath, ShoppingCart.TotalPriceInMainCurrency, CurrencyInfoProvider.GetFormattedPrice(ShoppingCart.TotalPriceInMainCurrency, CurrencyInfoProvider.GetMainCurrency(CMSContext.CurrentSiteID))); } // Raise finish order event ShoppingCartControl.RaiseOrderCompletedEvent(); // When in CMSDesk if (ShoppingCartControl.IsInternalOrder) { if (chkSendEmail.Checked) { // Send order notification emails OrderInfoProvider.SendOrderNotificationToAdministrator(ShoppingCart); OrderInfoProvider.SendOrderNotificationToCustomer(ShoppingCart); } } // When on the live site else if (ECommerceSettings.SendOrderNotification(SiteContext.CurrentSite.SiteName)) { // Send order notification emails OrderInfoProvider.SendOrderNotificationToAdministrator(ShoppingCart); OrderInfoProvider.SendOrderNotificationToCustomer(ShoppingCart); } return(true); }
private void wzdExport_NextButtonClick(object sender, WizardNavigationEventArgs e) { switch (e.CurrentStepIndex) { case 0: // Apply settings if (!configExport.ApplySettings()) { e.Cancel = true; return; } // Update settings ExportSettings = configExport.Settings; if (!configExport.ExportHistory) { ltlScriptAfter.Text = ScriptHelper.GetScript( @"var actDiv = document.getElementById('actDiv'); if (actDiv != null) { actDiv.style.display='block'; } var buttonsDiv = document.getElementById('buttonsDiv'); if (buttonsDiv != null) { buttonsDiv.disabled=true; } BTN_Disable('" + NextButton.ClientID + @"'); StartSelectionTimer();"); // Select objects asynchronously ctrlAsyncSelection.RunAsync(SelectObjects, WindowsIdentity.GetCurrent()); e.Cancel = true; } else { pnlExport.Settings = ExportSettings; pnlExport.ReloadData(); wzdExport.ActiveStepIndex = e.NextStepIndex; } break; case 1: // Apply settings if (!pnlExport.ApplySettings()) { e.Cancel = true; return; } ExportSettings = pnlExport.Settings; // Delete temporary files try { ExportProvider.DeleteTemporaryFiles(ExportSettings, true); } catch (Exception ex) { SetErrorLabel(ex.Message); e.Cancel = true; return; } try { // Save export history ExportHistoryInfo history = new ExportHistoryInfo { ExportDateTime = DateTime.Now, ExportFileName = ExportSettings.TargetFileName, ExportSettings = ExportSettings.GetXML(), ExportSiteID = ExportSettings.SiteId, ExportUserID = MembershipContext.AuthenticatedUser.UserID }; ExportHistoryInfo.Provider.Set(history); } catch (Exception ex) { SetErrorLabel(ex.Message); pnlError.ToolTip = EventLogProvider.GetExceptionLogMessage(ex); e.Cancel = true; return; } if (ExportSettings.SiteId > 0) { ExportSettings.EventLogSource = String.Format(ExportSettings.GetAPIString("ExportSite.EventLogSiteSource", "Export '{0}' site"), ResHelper.LocalizeString(ExportSettings.SiteInfo.DisplayName)); } // Start asynchronous export var manager = ExportManager; ExportSettings.LogContext = ctlAsyncExport.CurrentLog; manager.Settings = ExportSettings; ctlAsyncExport.RunAsync(manager.Export, WindowsIdentity.GetCurrent()); wzdExport.ActiveStepIndex = e.NextStepIndex; break; } }
/// <summary> /// When exception occures, log it to event log. /// </summary> /// <param name="messageTitle">Title message</param> /// <param name="ex">Exception to log</param> private void LogExceptionToEventLog(string messageTitle, Exception ex) { AddError(messageTitle + ": " + ex.Message); LogContext.LogEventToCurrent(EventType.ERROR, "Content", "PUBLISHDOC", EventLogProvider.GetExceptionLogMessage(ex), RequestContext.RawURL, currentUser.UserID, currentUser.UserName, 0, null, RequestContext.UserHostAddress, currentSiteId, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now); }
/// <summary> /// Refreshes the security parameters in macros for all the objects of the specified object types. /// Signs all the macros with the current user if the old salt is not specified. /// </summary> /// <param name="objectTypes">Object types</param> /// <param name="oldSalt">Old salt </param> /// <param name="newSalt">New salt</param> private void RefreshSecurityParams(IEnumerable <string> objectTypes, string oldSalt, string newSalt) { var oldSaltSpecified = !string.IsNullOrEmpty(oldSalt) && !chkRefreshAll.Checked; var newSaltSpecified = !string.IsNullOrEmpty(newSalt) && !chkUseCurrentSalt.Checked; processedObjects.Clear(); using (var context = new CMSActionContext()) { context.LogEvents = false; context.LogSynchronization = false; var processingString = GetString("macros.refreshsecurityparams.processing"); foreach (var objectType in objectTypes) { var niceObjectType = GetNiceObjectTypeName(objectType); AddLog(string.Format(processingString, niceObjectType)); try { var infos = new InfoObjectCollection(objectType); var csi = infos.TypeInfo.ClassStructureInfo; var orderByIndex = FindOrderByIndex(csi); if (orderByIndex != null) { infos.OrderByColumns = orderByIndex.GetOrderBy(); } infos.PageSize = 1000; // Skip object types derived from general data class object type to avoid duplicities if ((infos.TypeInfo.OriginalObjectType == DataClassInfo.OBJECT_TYPE) && (infos.TypeInfo.ObjectType != DataClassInfo.OBJECT_TYPE)) { continue; } foreach (var info in infos) { try { bool refreshed; if (oldSaltSpecified) { refreshed = MacroSecurityProcessor.RefreshSecurityParameters(info, oldSalt, newSaltSpecified ? newSalt : ValidationHelper.HashStringSalt, true); } else { if (chkRefreshAll.Checked && newSaltSpecified) { // Do not check integrity, but use new salt refreshed = MacroSecurityProcessor.RefreshSecurityParameters(info, MembershipContext.AuthenticatedUser.UserName, true, newSalt); } else { // Do not check integrity, sign everything with current user refreshed = MacroSecurityProcessor.RefreshSecurityParameters(info, MembershipContext.AuthenticatedUser.UserName, true); } } if (refreshed) { var objectName = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(info.Generalized.ObjectDisplayName)); processedObjects.Add(niceObjectType, objectName); } } catch (Exception ex) { string message = "Signing " + TypeHelper.GetNiceObjectTypeName(info.TypeInfo.ObjectType) + " " + info.Generalized.ObjectDisplayName + " failed: " + ex.Message; EventLogProvider.LogEvent(EventType.ERROR, "Import", "MACROSECURITY", message); } } } catch (Exception e) { AddLog(e.Message); EventLogProvider.LogException(EVENTLOG_SOURCE_REFRESHSECURITYPARAMS, "ERROR", e); } } } EventLogProvider.LogEvent(EventType.INFORMATION, EVENTLOG_SOURCE_REFRESHSECURITYPARAMS, "PROCESSEDOBJECTS", GetProcessedObjectsForEventLog()); }
/// <summary> /// Moves document. /// </summary> private void PerformAction(object parameter) { if (Action.ToLower() == "copy") { AddLog(GetString("media.copy.startcopy")); } else { AddLog(GetString("media.move.startmove")); } if (LibraryInfo != null) { // Library path (used in recursive copy process) string libPath = MediaLibraryInfoProvider.GetMediaLibraryFolderPath(CMSContext.CurrentSiteName, LibraryInfo.LibraryFolder); // Ensure libPath is in original path type libPath = Path.GetFullPath(libPath); // Original path on disk from query string origPath = Path.GetFullPath(DirectoryHelper.CombinePath(libPath, FolderPath)); // New path on disk string newPath = null; // Original path in DB string origDBPath = MediaLibraryHelper.EnsurePath(FolderPath); // New path in DB string newDBPath = null; AddLog(NewPath); // Check if requested folder is in library root folder if (!origPath.StartsWith(libPath, StringComparison.CurrentCultureIgnoreCase)) { CurrentError = GetString("media.folder.nolibrary"); AddLog(CurrentError); return; } string origFolderName = Path.GetFileName(origPath); if ((String.IsNullOrEmpty(Files) && !mAllFiles) && string.IsNullOrEmpty(origFolderName)) { NewPath = NewPath + "\\" + LibraryInfo.LibraryFolder; NewPath = NewPath.Trim('\\'); } newPath = NewPath; // Process current folder copy/move action if (String.IsNullOrEmpty(Files) && !AllFiles) { newPath = newPath.TrimEnd('\\') + '\\' + origFolderName; newPath = newPath.Trim('\\'); // Check if moving into same folder if ((Action.ToLower() == "move") && (newPath == FolderPath)) { CurrentError = GetString("media.move.foldermove"); AddLog(CurrentError); return; } // Error if moving folder into itself string newRootPath = Path.GetDirectoryName(newPath).Trim(); string newSubRootFolder = Path.GetFileName(newPath).ToLower().Trim(); string originalSubRootFolder = Path.GetFileName(FolderPath).ToLower().Trim(); if (String.IsNullOrEmpty(Files) && (Action.ToLower() == "move") && newPath.StartsWith(DirectoryHelper.EnsurePathBackSlash(FolderPath)) && (originalSubRootFolder == newSubRootFolder) && (newRootPath == FolderPath)) { CurrentError = GetString("media.move.movetoitself"); AddLog(CurrentError); return; } // Get unique path for copy or move string path = Path.GetFullPath(DirectoryHelper.CombinePath(libPath, newPath)); path = MediaLibraryHelper.EnsureUniqueDirectory(path); newPath = path.Remove(0, (libPath.Length + 1)); // Get new DB path newDBPath = MediaLibraryHelper.EnsurePath(newPath.Replace(DirectoryHelper.EnsurePathBackSlash(libPath), "")); } else { origDBPath = MediaLibraryHelper.EnsurePath(FolderPath); newDBPath = MediaLibraryHelper.EnsurePath(newPath.Replace(libPath, "")).Trim('/'); } // Error if moving folder into its subfolder if ((String.IsNullOrEmpty(Files) && !AllFiles) && (Action.ToLower() == "move") && newPath.StartsWith(DirectoryHelper.EnsurePathBackSlash(FolderPath))) { CurrentError = GetString("media.move.parenttochild"); AddLog(CurrentError); return; } // Error if moving files into same directory if ((!String.IsNullOrEmpty(Files) || AllFiles) && (Action.ToLower() == "move") && (newPath.TrimEnd('\\') == FolderPath.TrimEnd('\\'))) { CurrentError = GetString("media.move.fileserror"); AddLog(CurrentError); return; } NewPath = newPath; refreshScript = "if ((typeof(window.top.opener) != 'undefined') && (typeof(window.top.opener.RefreshLibrary) != 'undefined')) {window.top.opener.RefreshLibrary(" + ScriptHelper.GetString(NewPath.Replace('\\', '|')) + ");} else if ((typeof(window.top.wopener) != 'undefined') && (typeof(window.top.wopener.RefreshLibrary) != 'undefined')) { window.top.wopener.RefreshLibrary(" + ScriptHelper.GetString(NewPath.Replace('\\', '|')) + "); } window.top.close();"; // If mFiles is empty handle directory copy/move if (String.IsNullOrEmpty(Files) && !mAllFiles) { try { switch (Action.ToLower()) { case "move": MediaLibraryInfoProvider.MoveMediaLibraryFolder(CMSContext.CurrentSiteName, MediaLibraryID, origDBPath, newDBPath, false); break; case "copy": MediaLibraryInfoProvider.CopyMediaLibraryFolder(CMSContext.CurrentSiteName, MediaLibraryID, origDBPath, newDBPath, false, CurrentUser.UserID); break; } } catch (UnauthorizedAccessException ex) { CurrentError = GetString("general.erroroccurred") + " " + GetString("media.security.accessdenied"); EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFolder", this.Action, ex); AddLog(CurrentError); return; } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // When canceled CurrentInfo = GetString("general.actioncanceled"); AddLog(CurrentInfo); } else { // Log error CurrentError = GetString("general.erroroccurred") + " " + ex.Message; EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFolder", this.Action, ex); AddLog(CurrentError); return; } } catch (Exception ex) { CurrentError = GetString("general.erroroccurred") + " " + ex.Message; EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFolder", this.Action, ex); AddLog(CurrentError); return; } } else { string origDBFilePath = null; string newDBFilePath = null; if (!mAllFiles) { try { string[] files = Files.Split('|'); foreach (string filename in files) { origDBFilePath = (string.IsNullOrEmpty(origDBPath)) ? filename : origDBPath + "/" + filename; newDBFilePath = (string.IsNullOrEmpty(newDBPath)) ? filename : newDBPath + "/" + filename; AddLog(filename); CopyMove(origDBFilePath, newDBFilePath); } } catch (UnauthorizedAccessException ex) { CurrentError = GetString("general.erroroccurred") + " " + ResHelper.GetString("media.security.accessdenied"); EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFile", this.Action, ex); AddLog(CurrentError); return; } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // When canceled CurrentInfo = GetString("general.actioncanceled"); AddLog(CurrentInfo); } else { // Log error CurrentError = GetString("general.erroroccurred") + " " + ex.Message; EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFile", this.Action, ex); AddLog(CurrentError); return; } } catch (Exception ex) { CurrentError = GetString("general.erroroccurred") + " " + ex.Message; EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFile", this.Action, ex); AddLog(CurrentError); return; } } else { HttpContext context = (parameter as HttpContext); if (context != null) { HttpContext.Current = context; DataSet files = GetFileSystemDataSource(); if (!DataHelper.IsEmpty(files)) { foreach (DataRow file in files.Tables[0].Rows) { string fileName = ValidationHelper.GetString(file["FileName"], ""); AddLog(fileName); origDBFilePath = (string.IsNullOrEmpty(origDBPath)) ? fileName : origDBPath + "/" + fileName; newDBFilePath = (string.IsNullOrEmpty(newDBPath)) ? fileName : newDBPath + "/" + fileName; // Clear current httpcontext for CopyMove action in threat HttpContext.Current = null; try { CopyMove(origDBFilePath, newDBFilePath); } catch (UnauthorizedAccessException ex) { CurrentError = GetString("general.erroroccurred") + " " + ResHelper.GetString("media.security.accessdenied"); EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFile", this.Action, ex); AddLog(CurrentError); return; } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // When canceled CurrentInfo = GetString("general.actioncanceled"); AddLog(CurrentInfo); } else { // Log error CurrentError = GetString("general.erroroccurred") + " " + ex.Message; EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFile", this.Action, ex); AddLog(CurrentError); return; } } catch (Exception ex) { CurrentError = GetString("general.erroroccurred") + " " + ex.Message; EventLogProvider ev = new EventLogProvider(); ev.LogEvent("MediaFile", this.Action, ex); AddLog(CurrentError); return; } } } } } } } }
/// <summary> /// When exception occurs, log it to event log. /// </summary> /// <param name="ex">Exception to log</param> private void LogExceptionToEventLog(Exception ex) { EventLogProvider.LogEvent(EventType.ERROR, "Content", "TRANSLATEDOC", EventLogProvider.GetExceptionLogMessage(ex), RequestContext.RawURL, currentUser.UserID, currentUser.UserName, 0, null, RequestContext.UserHostAddress, currentSite.SiteID); AddError(ResHelper.GetString("ContentRequest.TranslationFailed", currentCulture) + ex.Message); }
/// <summary> /// Reloads the grid data. /// </summary> public override void ReloadData() { try { // Ensure grid definition before realod data LoadGridDefinition(); RaiseOnBeforeDataReload(); rowIndex = 1; // Get Current TOP N if (CurrentPageSize > 0) { int currentPageIndex = Pager.CurrentPage; int pageSize = (CurrentPageSize > 0) ? CurrentPageSize : UniGridView.PageSize; CurrentTopN = pageSize * (currentPageIndex + Pager.CurrentPagesGroupSize); } if (CurrentTopN < TopN) { CurrentTopN = TopN; } // If first/last button and direct page contol in pager is hidden use current topN for better performance if (!Pager.ShowDirectPageControl && !Pager.ShowFirstLastButtons) { TopN = CurrentTopN; } // Retrieve data UniGridView.DataSource = RetrieveData(); // Sort external dataset only if no query and info object is set if (string.IsNullOrEmpty(Query) && (InfoObject == null) && (!DataHelper.DataSourceIsEmpty(UniGridView.DataSource) && !DataSourceIsSorted)) { SortUniGridDataSource(); } RaiseOnAfterDataReload(); SetUnigridControls(); // Check if datasource is loaded if (DataHelper.DataSourceIsEmpty(GridView.DataSource) && (pagerElem.CurrentPage > 1)) { pagerElem.UniPager.CurrentPage = 1; ReloadData(); } // Resolve the edit action URL if (!String.IsNullOrEmpty(EditActionUrl)) { EditActionUrl = CMSContext.ResolveMacros(EditActionUrl); } SortColumns.Clear(); UniGridView.DataBind(); mRowsCount = DataHelper.GetItemsCount(UniGridView.DataSource); CheckFilterVisibility(); } catch (Exception ex) { lblError.Text = GetString("unigrid.error.reload"); lblError.Visible = true; // Display tooltip only development mode is enabled if (SettingsKeyProvider.DevelopmentMode) { lblError.ToolTip = ex.Message; } // Log exception EventLogProvider ev = new EventLogProvider(); ev.LogEvent("UniGrid", "RELOADDATA", ex.InnerException ?? ex); } }
/// <summary> /// Process this step. /// </summary> public override bool ProcessStep() { // Do not process step if order is paid if (OrderIsPaid) { return(false); } // Shopping cart units are already saved in database (on "Update" or on "btnAddProduct_Click" actions) bool isOK = false; if (ShoppingCart != null) { // Reload data ReloadData(); // Check available items before "Check out" ShoppingCartCheckResult checkResult = ShoppingCartInfoProvider.CheckShoppingCart(ShoppingCart); if (checkResult.CheckFailed) { lblError.Text = checkResult.GetHTMLFormattedMessage(); } else if (ShoppingCartControl.CheckoutProcessType == CheckoutProcessEnum.CMSDeskOrderItems) { // Indicates whether order saving process is successful isOK = true; try { ShoppingCartInfoProvider.SetOrder(ShoppingCart); } catch (Exception ex) { // Log exception EventLogProvider.LogException("Shopping cart", "SAVEORDER", ex, ShoppingCart.ShoppingCartSiteID); isOK = false; } if (isOK) { lblInfo.Text = GetString("general.changessaved"); // Send order notification when editing existing order if (ShoppingCartControl.CheckoutProcessType == CheckoutProcessEnum.CMSDeskOrderItems) { if (chkSendEmail.Checked) { OrderInfoProvider.SendOrderNotificationToAdministrator(ShoppingCart); OrderInfoProvider.SendOrderNotificationToCustomer(ShoppingCart); } } // Send order notification emails when on the live site else if (ECommerceSettings.SendOrderNotification(SiteContext.CurrentSite.SiteName)) { OrderInfoProvider.SendOrderNotificationToAdministrator(ShoppingCart); OrderInfoProvider.SendOrderNotificationToCustomer(ShoppingCart); } } else { lblError.Text = GetString("ecommerce.orderpreview.errorordersave"); } } // Go to the next step else { // Save other options if (!ShoppingCartControl.IsInternalOrder) { ShoppingCartInfoProvider.SetShoppingCartInfo(ShoppingCart); } isOK = true; } } return(isOK); }
protected void wzdImport_NextButtonClick(object sender, WizardNavigationEventArgs e) { switch (e.CurrentStepIndex) { // Import type case 0: { if (!siteType.SelectTemplate) { try { // Get blank web template WebTemplateInfo wi = WebTemplateInfoProvider.GetWebTemplateInfo("BlankSite"); if (wi == null) { e.Cancel = true; return; } WebTemplateID = wi.WebTemplateId; string path = Server.MapPath(wi.WebTemplateFileName); if (File.Exists(path + "\\template.zip")) { // Template from zip file path += "\\" + ZipStorageProvider.GetZipFileName("template.zip"); ImportSettings.TemporaryFilesPath = path; ImportSettings.SourceFilePath = path; ImportSettings.TemporaryFilesCreated = true; ImportSettings.RefreshMacroSecurity = true; } else { // Init the settings ImportSettings.TemporaryFilesCreated = false; ImportSettings.SourceFilePath = Server.MapPath(wi.WebTemplateFileName); ImportSettings.RefreshMacroSecurity = true; } if (!File.Exists(ImportSettings.SourceFilePath)) { try { ImportProvider.CreateTemporaryFiles(ImportSettings); } catch (Exception ex) { lblError.Visible = true; lblError.Text = ex.Message; e.Cancel = true; return; } } if (SiteInfoProvider.GetSitesCount() == 0) { // No site exists, overwrite all ImportSettings.ImportType = ImportTypeEnum.All; ImportSettings.CopyFiles = false; } else { // Some site exists, only new objects ImportSettings.ImportType = ImportTypeEnum.New; } ltlScriptAfter.Text = ScriptHelper.GetScript( "var actDiv = document.getElementById('actDiv'); \n" + "if (actDiv != null) { actDiv.style.display='block'; } \n" + "var buttonsDiv = document.getElementById('buttonsDiv'); if (buttonsDiv != null) { buttonsDiv.disabled=true; } \n" + "BTN_Disable('" + NextButton.ClientID + "'); \n" + "StartSelectionTimer();" ); // Preselect objects asynchronously ctrlAsync.Parameter = "N"; ctrlAsync.RunAsync(SelectObjects, WindowsIdentity.GetCurrent()); e.Cancel = true; } catch (Exception ex) { lblError.Text = ex.Message; e.Cancel = true; return; } } else { siteDetails.SiteName = null; siteDetails.SiteDisplayName = null; selectTemplate.ReloadData(); } wzdImport.ActiveStepIndex++; } break; // Template selection case 1: { if (!selectTemplate.ApplySettings()) { e.Cancel = true; return; } // Init the settings WebTemplateInfo wi = WebTemplateInfoProvider.GetWebTemplateInfo(selectTemplate.WebTemplateId); if (wi == null) { throw new Exception("Web template not found."); } ImportSettings.IsWebTemplate = true; string path = Server.MapPath(wi.WebTemplateFileName); if (File.Exists(path + "\\template.zip")) { // Template from zip file path += "\\" + ZipStorageProvider.GetZipFileName("template.zip"); ImportSettings.TemporaryFilesPath = path; ImportSettings.SourceFilePath = path; ImportSettings.TemporaryFilesCreated = true; ImportSettings.RefreshMacroSecurity = true; } else { // Template from folder ImportSettings.TemporaryFilesCreated = false; ImportSettings.SourceFilePath = path; ImportSettings.RefreshMacroSecurity = true; try { ImportProvider.CreateTemporaryFiles(ImportSettings); } catch (Exception ex) { lblError.Visible = true; lblError.Text = ex.Message; e.Cancel = true; return; } } if (SiteInfoProvider.GetSitesCount() == 0) { // No site exists, overwrite all ImportSettings.ImportType = ImportTypeEnum.All; } else { // Some site exists, only new objects ImportSettings.ImportType = ImportTypeEnum.New; } ltlScriptAfter.Text = ScriptHelper.GetScript( "var actDiv = document.getElementById('actDiv');\n" + "if (actDiv != null) { actDiv.style.display='block'; }\n" + "var buttonsDiv = document.getElementById('buttonsDiv');\n" + "if (buttonsDiv != null) { buttonsDiv.disabled=true; }\n" + "BTN_Disable('" + NextButton.ClientID + "');\n" + "BTN_Disable('" + PreviousButton.ClientID + "');\n" + "StartSelectionTimer();" ); // Preselect objects asynchronously ctrlAsync.Parameter = "T"; ctrlAsync.RunAsync(SelectObjects, WindowsIdentity.GetCurrent()); e.Cancel = true; } break; // Site details case 2: if (!siteDetails.ApplySettings()) { e.Cancel = true; return; } // Update settings ImportSettings = siteDetails.Settings; Culture = siteDetails.Culture; pnlImport.ReloadData(true); wzdImport.ActiveStepIndex++; break; // Objects selection case 3: if (!pnlImport.ApplySettings()) { e.Cancel = true; return; } // Check licences string error = ImportExportControl.CheckLicenses(ImportSettings); if (!string.IsNullOrEmpty(error)) { lblError.Text = error; e.Cancel = true; return; } ImportSettings = pnlImport.Settings; PreviousButton.Enabled = false; NextButton.Enabled = false; SiteName = ImportSettings.SiteName; Domain = ImportSettings.SiteDomain; // Init the Mimetype helper (required for the Import) MimeTypeHelper.LoadMimeTypes(); // Start asynchronnous Import ImportSettings.SetSettings(ImportExportHelper.SETTINGS_DELETE_TEMPORARY_FILES, false); ImportSettings.DefaultProcessObjectType = ProcessObjectEnum.Selected; ImportManager.Settings = ImportSettings; // Import site asynchronously ctrlImport.RunAsync(ImportManager.Import, WindowsIdentity.GetCurrent()); ctrlImport.PostbackOnError = false; ltlScript.Text = ScriptHelper.GetScript("StartImportStateTimer();"); wzdImport.ActiveStepIndex++; break; // Import progress case 4: PreviousButton.Visible = false; CultureHelper.SetPreferredCulture(Culture); if (siteType.SelectTemplate) { // Done finishSite.Domain = Domain; finishSite.SiteIsRunning = SiteIsRunning; wzdImport.ActiveStepIndex = 7; } else { if (ImportManager.Settings.IsWarning()) { try { // Convert default culture TreeProvider tree = new TreeProvider(CMSContext.CurrentUser); tree.ChangeSiteDefaultCulture(SiteName, Culture, "en-US"); // Change root GUID TreeNode root = DocumentHelper.GetDocument(SiteName, "/", Culture, false, "cms.root", null, null, 1, false, null, tree); if (root != null) { root.NodeGUID = Guid.NewGuid(); DocumentHelper.UpdateDocument(root, tree); } } catch (Exception ex) { EventLogProvider ev = new EventLogProvider(); ev.LogEvent("NewSiteWizard", "FINISH", ex); lblError.Text = ex.Message; e.Cancel = true; return; } } selectMaster.SiteName = SiteName; selectMaster.ReloadData(); } break; // Master template case 5: if (!selectMaster.ApplySettings()) { e.Cancel = true; return; } siteStructure.SiteName = SiteName; break; // Define site structure case 6: finishSite.Domain = Domain; finishSite.SiteIsRunning = SiteIsRunning; break; // Other steps default: wzdImport.ActiveStepIndex = e.NextStepIndex; break; } }
public void SynchronizeComplete(object parameter) { string result = null; eventCode = "SYNCCOMPLETE"; CanceledString = GetString("Tasks.SynchronizationCanceled"); try { int sid = serverId; if (sid <= 0) { sid = SynchronizationInfoProvider.ENABLED_SERVERS; } AddLog(GetString("Synchronization.LoggingTasks")); // Synchronize root node IEnumerable <ISynchronizationTask> tasks = DocumentSynchronizationHelper.LogDocumentChange(SiteContext.CurrentSiteName, "/", TaskTypeEnum.UpdateDocument, null, sid, false, false); AddLog(GetString("Synchronization.RunningTasks")); // Run the synchronization StagingHelper.RunSynchronization(tasks, serverId, true, currentSiteId, AddLog); AddLog(GetString("Synchronization.LoggingTasks")); // Synchronize subnodes tasks = DocumentSynchronizationHelper.LogDocumentChange(SiteContext.CurrentSiteName, "/%", TaskTypeEnum.UpdateDocument, null, sid, false, false); AddLog(GetString("Synchronization.RunningTasks")); // Run the synchronization result = StagingHelper.RunSynchronization(tasks, serverId, true, currentSiteId, AddLog); // Log possible errors if (!string.IsNullOrEmpty(result)) { CurrentError = GetString("Tasks.SynchronizationFailed"); AddErrorLog(CurrentError, null); } else { CurrentInfo = GetString("Tasks.SynchronizationOK"); AddLog(CurrentInfo); } } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // Canceled by user CurrentInfo = CanceledString; AddLog(CurrentInfo); } else { CurrentError = GetString("Tasks.SynchronizationFailed"); AddErrorLog(CurrentError, result); } } catch (Exception ex) { EventLogProvider.LogException("Staging", "SYNCHRONIZE", ex); CurrentError = GetString("Tasks.SynchronizationFailed") + ": " + ex.Message; AddErrorLog(CurrentError); } finally { // Finalize log context FinalizeContext(); } }
/// <summary> /// Saves modified image data. /// </summary> /// <param name="name">Image name</param> /// <param name="extension">Image extension</param> /// <param name="mimetype">Image mimetype</param> /// <param name="title">Image title</param> /// <param name="description">Image description</param> /// <param name="binary">Image binary data</param> /// <param name="width">Image width</param> /// <param name="height">Image height</param> private void SaveImage(string name, string extension, string mimetype, string title, string description, byte[] binary, int width, int height) { // Process media file if (mfi == null) { mfi = MediaFileInfoProvider.GetMediaFileInfo(mediafileGuid, this.CurrentSiteName); } if (mfi != null) { MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(mfi.FileLibraryID); if (mli != null) { string path = Path.GetDirectoryName(DirectoryHelper.CombinePath(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(mli.LibraryID), mfi.FilePath)); bool permissionsOK = DirectoryHelper.CheckPermissions(path, false, true, true, true); if (permissionsOK) { MediaFileInfo originalMfi = mfi.Clone(true); try { // Ensure object version SynchronizationHelper.EnsureObjectVersion(mfi); if (isPreview && !String.IsNullOrEmpty(PreviewPath)) { SiteInfo si = SiteInfoProvider.GetSiteInfo(mfi.FileSiteID); if (si != null) { string previewExt = (!String.IsNullOrEmpty(extension) && (extension != OldPreviewExt)) ? extension : OldPreviewExt; string previewName = Path.GetFileNameWithoutExtension(PreviewPath); string previewFolder = MediaLibraryHelper.EnsurePath(DirectoryHelper.CombinePath(Path.GetDirectoryName(mfi.FilePath).TrimEnd('/'), MediaLibraryHelper.GetMediaFileHiddenFolder(si.SiteName))); // Delete old preview files with thumbnails MediaFileInfoProvider.DeleteMediaFilePreview(CMSContext.CurrentSiteName, mli.LibraryID, mfi.FilePath, false); MediaFileInfoProvider.DeleteMediaFilePreviewThumbnails(mfi); // Save preview file MediaFileInfoProvider.SaveFileToDisk(si.SiteName, mli.LibraryFolder, previewFolder, previewName, previewExt, mfi.FileGUID, binary, false, false); // Log synchronization task SynchronizationHelper.LogObjectChange(mfi, TaskTypeEnum.UpdateObject); } } else { string newExt = null; string newName = null; if (!String.IsNullOrEmpty(extension)) { newExt = extension; } if (!String.IsNullOrEmpty(mimetype)) { mfi.FileMimeType = mimetype; } mfi.FileTitle = title; mfi.FileDescription = description; if (width > 0) { mfi.FileImageWidth = width; } if (height > 0) { mfi.FileImageHeight = height; } if (binary != null) { mfi.FileBinary = binary; mfi.FileSize = binary.Length; } // Test all parameters to empty values and update new value if available if (!String.IsNullOrEmpty(name)) { newName = name; } // If filename changed move preview file and remove all ald thumbnails if ((!String.IsNullOrEmpty(newName) && (mfi.FileName != newName)) || (!String.IsNullOrEmpty(newExt) && (mfi.FileExtension.ToLower() != newExt.ToLower()))) { SiteInfo si = SiteInfoProvider.GetSiteInfo(mfi.FileSiteID); if (si != null) { string fileName = (newName != null ? newName : mfi.FileName); string fileExt = (newExt != null ? newExt : mfi.FileExtension); string newPath = MediaFileInfoProvider.GetMediaFilePath(mfi.FileLibraryID, DirectoryHelper.CombinePath(Path.GetDirectoryName(mfi.FilePath), fileName) + fileExt); string filePath = MediaFileInfoProvider.GetMediaFilePath(mfi.FileLibraryID, mfi.FilePath); // Rename file only if file with same name does not exsists if (!File.Exists(newPath)) { // Ensure max length of file path if (newPath.Length < 260) { // Remove old thumbnails MediaFileInfoProvider.DeleteMediaFileThumbnails(mfi); MediaFileInfoProvider.DeleteMediaFilePreviewThumbnails(mfi); // Move media file MediaFileInfoProvider.MoveMediaFile(si.SiteName, mli.LibraryID, mfi.FilePath, DirectoryHelper.CombinePath(Path.GetDirectoryName(mfi.FilePath), fileName) + fileExt, false); // Set new file name or extension mfi.FileName = fileName; mfi.FileExtension = fileExt; // Ensure new binary if (binary != null) { mfi.FileBinary = binary; mfi.FileSize = binary.Length; } } else { throw new IOExceptions.PathTooLongException(); } } else { baseImageEditor.LblLoadFailed.Visible = true; baseImageEditor.LblLoadFailed.ResourceString = "img.errors.fileexists"; SavingFailed = true; return; } } } else { // Remove old thumbnails MediaFileInfoProvider.DeleteMediaFileThumbnails(mfi); // Remove original media file before save string filePath = MediaFileInfoProvider.GetMediaFilePath(mfi.FileLibraryID, mfi.FilePath); if (File.Exists(filePath)) { File.Delete(filePath); } } // Save new data MediaFileInfoProvider.SetMediaFileInfo(mfi, false); } } catch (Exception e) { // Log exception EventLogProvider ev = new EventLogProvider(); ev.LogEvent("ImageEditor", "Save file", e); baseImageEditor.LblLoadFailed.Visible = true; baseImageEditor.LblLoadFailed.ResourceString = "img.errors.processing"; ScriptHelper.AppendTooltip(baseImageEditor.LblLoadFailed, e.Message, "help"); this.SavingFailed = true; // Save original media file info MediaFileInfoProvider.SetMediaFileInfo(originalMfi, false); } } } } }
/// <summary> /// Internal method for synchronizing current document. /// </summary> /// <param name="parameter">Parameter</param> /// <param name="eventCodeForLog">Event code to set</param> /// <param name="finalizeEventLog">Indicates whether to finalize eventlog</param> /// <returns>Result of synchronization</returns> private string SynchronizeCurrentInternal(object parameter, string eventCodeForLog, bool finalizeEventLog) { string result = string.Empty; eventCode = eventCodeForLog; bool finish = ValidationHelper.GetBoolean(parameter, true); CanceledString = GetString("Tasks.SynchronizationCanceled"); int sid = serverId; if (sid <= 0) { sid = SynchronizationInfoProvider.ENABLED_SERVERS; } AddLog(GetString("Synchronization.LoggingTasks")); try { // Get the tasks var settings = new LogMultipleDocumentChangeSettings() { EnsurePublishTask = true, NodeAliasPath = aliasPath, TaskType = TaskTypeEnum.UpdateDocument, ServerID = sid, KeepTaskData = false, RunAsynchronously = false, SiteName = currentSiteName }; IEnumerable <ISynchronizationTask> tasks = DocumentSynchronizationHelper.LogDocumentChange(settings); AddLog(GetString("Synchronization.RunningTasks")); // Run the synchronization result = StagingHelper.RunSynchronization(tasks, serverId, true, currentSiteId, AddLog); if (finish) { // Log possible error if (!String.IsNullOrEmpty(result)) { CurrentError = GetString("Tasks.SynchronizationFailed"); AddErrorLog(CurrentError, null); } else { CurrentInfo = GetString("Tasks.SynchronizationOK"); AddLog(CurrentInfo); } } } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // Canceled by user CurrentInfo = CanceledString; AddLog(CurrentInfo); } else { CurrentError = GetString("Tasks.SynchronizationFailed"); AddErrorLog(CurrentError, result); } } catch (Exception ex) { EventLogProvider.LogException("Staging", "SYNCHRONIZE", ex); CurrentError = GetString("Tasks.SynchronizationFailed") + ": " + ex.Message; AddErrorLog(CurrentError); } finally { if (finalizeEventLog) { // Finalize log context FinalizeContext(); } } return(result); }
protected void Page_Load(object sender, EventArgs e) { if (!string.IsNullOrWhiteSpace(Request.QueryString["fileid"]) && !string.IsNullOrWhiteSpace(Request.QueryString["containerid"])) { _fileId = Request.QueryString["fileid"]; _containerId = new Guid(Request.QueryString["containerid"]); } if (!IsPostBack) { btnProcess.InnerText = GetString("Kadena.MailingList.ProcessList", string.Empty); btnReupload.InnerText = GetString("Kadena.MailingList.ReuploadList", string.Empty); } if (!string.IsNullOrWhiteSpace(_fileId) && _containerId != Guid.Empty) { var parsingClient = DIContainer.Resolve <IParsingClient>(); var parseResult = parsingClient.GetHeaders(_fileId.ToString()).Result; if (parseResult.Success) { var headers = parseResult.Payload.ToArray(); foreach (var cs in _columnSelectors) { var sel = (FindControl($"sel{cs.Item2}") as HtmlSelect); if (sel != null) { var selectedValue = GetColumnValue(cs.Item2); var valueToSelect = -1; sel.Items.Clear(); var emptyItem = new ListItem(GetString("Kadena.MailingList.Empty"), GetString("Kadena.MailingList.Empty")); if (!cs.Item3) { emptyItem.Attributes["disabled"] = string.Empty; } sel.Items.Add(emptyItem); for (int i = 0; i < headers.Length; i++) { sel.Items.Add(new ListItem(headers[i], i.ToString())); if (headers[i].ToLower().Contains(cs.Item1.ToLower())) { valueToSelect = i; } } if (selectedValue > -1) { valueToSelect = selectedValue; } sel.Value = valueToSelect < 0 ? GetString("Kadena.MailingList.Empty") : valueToSelect.ToString(); } } } else { EventLogProvider.LogEvent(EventType.ERROR, GetType().Name, "ParsingHeaders", parseResult.ErrorMessages, siteId: CurrentSite.SiteID); } } }
/// <summary> /// When exception occurs, log it to event log. /// </summary> private void LogExceptionToEventLog(Exception ex) { EventLogProvider.LogEvent(EventType.ERROR, "System deployment", "DEPLOYMENT", EventLogProvider.GetExceptionLogMessage(ex), RequestContext.RawURL, CurrentUser.UserID, CurrentUser.UserName, 0, null, RequestContext.UserHostAddress, SiteContext.CurrentSiteID); AddError(ResHelper.GetString("Deployment.DeploymentFailed") + ": " + ex.Message); }
protected void gridHistory_OnAction(string actionName, object actionArgument) { int versionHistoryId = ValidationHelper.GetInteger(actionArgument, 0); actionName = actionName.ToLowerCSafe(); switch (actionName.ToLowerCSafe()) { case "rollback": case "fullrollback": if (versionHistoryId > 0) { // Check permissions if (CheckPermissions && !AllowModify) { ShowError(GetString("History.ErrorNotAllowedToModify")); } else { try { var newVersionId = ObjectVersionManager.RollbackVersion(versionHistoryId, (actionName == "fullrollback")); ObjectVersionHistoryInfo newVersion = ObjectVersionHistoryInfoProvider.GetVersionHistoryInfo(newVersionId); // Set object to null because after rollback it doesn't contain current data Object = null; gridHistory.ReloadData(); if (OnAfterRollback != null) { OnAfterRollback(this, null); } ShowConfirmation(GetString("objectversioning.rollbackOK")); ScriptHelper.RegisterStartupScript(this, typeof(string), "RefreshContent", ScriptHelper.GetScript("RefreshRelatedContent_" + ClientID + "();")); ScriptHelper.RefreshTabHeader(Page, newVersion.VersionObjectDisplayName); } catch (CodeNameNotUniqueException ex) { ShowError(String.Format(GetString("objectversioning.restorenotuniquecodename"), (ex.Object != null) ? "('" + ex.Object.ObjectCodeName + "')" : null)); } catch (Exception ex) { ShowError(GetString("objectversioning.recyclebin.restorationfailed") + " " + GetString("general.seeeventlog")); // Log to event log EventLogProvider.LogException("Object version list", "OBJECTRESTORE", ex); } } } break; case "destroy": if (versionHistoryId > 0) { // Check permissions if (CheckPermissions && !AllowDestroy) { ShowError(GetString("History.ErrorNotAllowedToDestroy")); } else { ObjectVersionManager.DestroyObjectVersion(versionHistoryId); ShowConfirmation(GetString("objectversioning.destroyOK")); } } break; } }
protected void btnClearCache_Click(object sender, EventArgs e) { if (StopProcessing) { return; } // Clear the cache CacheHelper.ClearCache(null, true); Functions.ClearHashtables(); // Drop the routes CMSMvcHandler.DropAllRoutes(); // Disposes all zip files ZipStorageProvider.DisposeAll(); // Collect the memory GC.Collect(); GC.WaitForPendingFinalizers(); // Log event EventLogProvider eventLog = new EventLogProvider(); eventLog.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, "System", "CLEARCACHE", null, GetString("Administration-System.ClearCacheSuccess")); ShowConfirmation(GetString("Administration-System.ClearCacheSuccess")); LoadData(); }
public string Execute(TaskInfo ti) { try { string eventName = string.Empty; string eventStartdate = string.Empty; string eventEnddate = string.Empty; string eventDescription = string.Empty; string eventCategory = string.Empty; long eventProductId; StringBuilder documentsAddedStatus = new StringBuilder();//string eventLocation = string.Empty; string eventWebsite = string.Empty; string eventContact = string.Empty; string eventFax = string.Empty; string eventFacilityID = string.Empty; //Communicates with personify web service and gets the list of meetings string dataServiceUri = ConfigurationManager.AppSettings["svcUri_Base"]; string dataServiceUserName = ConfigurationManager.AppSettings["svcLogin"]; string dataServicePassword = ConfigurationManager.AppSettings["svcPassword"]; Uri ServiceUri = new Uri(dataServiceUri); PersonifyEntitiesBase DataAccessLayer = new PersonifyEntitiesBase(ServiceUri); DataAccessLayer.Credentials = new NetworkCredential(dataServiceUserName, dataServicePassword); var eventsListPersonify = DataAccessLayer.WebProductViews.Where(p => p.Subsystem == "MTG" && p.MeetingEndDate >= DateTime.Now.AddDays(-2)).ToList(); DataSet eventsList = DocumentHelper.GetDocuments("SME.EVENT") .OnSite(SiteContext.CurrentSiteName) .Culture("en-us") .CombineWithDefaultCulture(false) .All(); string un = "smeadmin"; string pwd = "533@dm1n"; //authenticates user for publishing documents/pages/events AuthenticateUser(un, pwd); UserInfo ui = UserInfoProvider.GetUserInfo(un); // Create new instance of the Tree provider TreeProvider tree = new TreeProvider(ui); // Get parent node TreeNode parentNode = tree.SelectSingleNode(SiteContext.CurrentSiteName, "/events-professional-development/events", "en-us"); foreach (var events in eventsListPersonify) { eventName = events.ShortName; eventProductId = events.ProductId; eventStartdate = events.MeetingStartDate.ToString(); eventEnddate = events.MeetingEndDate.ToString(); eventDescription = events.WebShortDescription; eventCategory = events.ProductClassCodeString; eventFacilityID = events.FacilityMasterCustomerId; string[] addressDelimiter = new string[] { "\r\n" }; string[] address; string eventAddress = string.Empty; string eventCity = string.Empty; string eventCountry = string.Empty; string eventStateProvince = string.Empty; string eventZipPostalCode = string.Empty; string eventLocation = string.Empty; string eventEmail = string.Empty; string eventPhone = string.Empty; bool isAllowSocialEvents = events.ProductClassCodeString.ToLower() != "social_event"; if (eventFacilityID != "" && eventFacilityID != null) { var CommuniteeList = DataAccessLayer.AddressInfos.Where(p => p.MasterCustomerId == eventFacilityID).ToList(); foreach (var item in CommuniteeList) { address = item.AddressLabel.Split(addressDelimiter, StringSplitOptions.None); eventAddress = address[0] + " " + address[1]; eventCity = item.City; eventCountry = item.CountryCode; eventStateProvince = item.State; eventZipPostalCode = item.PostalCode; eventLocation = item.City + ", " + item.CountryCode; eventEmail = item.MailStop; eventPhone = item.PersonalLine; } } if (parentNode != null) { if (!DocumentExists(events.ProductId, eventsList) && isAllowSocialEvents) { // Create documents var newNode = CMS.DocumentEngine.TreeNode.New("SME.EVENT", tree); newNode.DocumentName = events.LongName; newNode.NodeAlias = eventName; newNode.DocumentCulture = "en-us"; newNode.SetValue("EventName", eventName); newNode.SetValue("ProductId", eventProductId); newNode.SetValue("StartDate", eventStartdate); newNode.SetValue("EndDate", eventEnddate); newNode.SetValue("EventDetails", eventDescription); newNode.SetValue("EventCategory", eventCategory); newNode.SetValue("Location", eventLocation); //newNode.SetValue("TargetUrl", eventWebsite); //newNode.SetValue("Contact", eventContact); newNode.SetValue("email", eventEmail); newNode.SetValue("Address", eventAddress); newNode.SetValue("City", eventCity); newNode.SetValue("State_Province", eventStateProvince); newNode.SetValue("Zip_PostalCode", eventZipPostalCode); newNode.SetValue("Country", eventCountry); newNode.SetValue("Phone", eventPhone); newNode.SetValue("AllowPersonifyUpdate", true); //newNode.SetValue("Fax", eventFax); newNode.DocumentPageTemplateID = 24357; newNode.Insert(parentNode); //newNode.Publish(); documentsAddedStatus.Append("Meeting " + eventName + " added into kentico at " + DateTime.Now + Environment.NewLine); } else { // Update the Document var updateNode = eventsList.Tables[0].AsEnumerable().Where(row => events.ProductId == row.Field <long?>("ProductId")).Select(row => new { ID = row.Field <int>("NodeId"), }).ToList(); if (updateNode.Count == 1 && isAllowSocialEvents) { TreeNode node = tree.SelectSingleNode(updateNode[0].ID, "en-us", "SME.Event"); if (node.GetBooleanValue("AllowPersonifyUpdate", false)) { //node.DocumentName = events.LongName; //node.NodeAlias = eventName; node.DocumentCulture = "en-us"; //node.SetValue("EventName", eventName); node.SetValue("ProductId", eventProductId); node.SetValue("StartDate", eventStartdate); node.SetValue("EndDate", eventEnddate); //this is the optional field which editors can update from CMS Desk. //node.SetValue("EventDetails", eventDescription); node.SetValue("EventCategory", eventCategory); node.SetValue("Location", eventLocation); //node.SetValue("TargetUrl", eventWebsite); //node.SetValue("Contact", eventContact); node.SetValue("email", eventEmail); node.SetValue("Address", eventAddress); node.SetValue("City", eventCity); node.SetValue("State_Province", eventStateProvince); node.SetValue("Zip_PostalCode", eventZipPostalCode); node.SetValue("Country", eventCountry); node.SetValue("Phone", eventPhone); //node.SetValue("Fax", eventFax); node.SetValue("LastUpdate", DateTime.Now); node.DocumentPageTemplateID = 24357; node.Update(); DocumentHelper.UpdateDocument(node); //node.Publish(); documentsAddedStatus.Append("Meeting " + eventName + " updated in kentico at " + DateTime.Now + Environment.NewLine); } else { documentsAddedStatus.Append("Meeting " + eventName + " skipped due to document setting in document at " + DateTime.Now + Environment.NewLine); } } } } } EventLogProvider.LogInformation("PersonifyMeeting", "Import", documentsAddedStatus.ToString()); } catch (Exception ex) { EventLogProvider.LogException("PersonifyMeeting", "Import", ex); } return(null); }
private void DisplayError(Exception ex) { pnlProgress.Visible = false; btnOk.Enabled = false; pnlDetails.Visible = false; string displayName = null; if (exportObj != null) { displayName = exportObj.ObjectDisplayName; } lblResult.Text = string.Format(GetString("RestoreObject.Error"), HTMLHelper.HTMLEncode(displayName), ex.Message); lblResult.ToolTip = EventLogProvider.GetExceptionLogMessage(ex); lblResult.CssClass = "ErrorLabel"; // Log to the event log EventLogProvider ev = new EventLogProvider(); ev.LogEvent("Export", "RestoreObject", ex); }
/// <summary> /// Provides operations necessary to create and store new attachment. /// </summary> private void HandleAttachmentUpload(bool fieldAttachment) { // New attachment DocumentAttachment newAttachment = null; string message = string.Empty; bool fullRefresh = false; bool refreshTree = false; try { // Get the existing document if (DocumentID != 0) { // Get document node = DocumentHelper.GetDocument(DocumentID, TreeProvider); if (node == null) { throw new Exception("Given page doesn't exist!"); } } #region "Check permissions" if (CheckPermissions) { CheckNodePermissions(node); } #endregion // Check the allowed extensions CheckAllowedExtensions(); // Standard attachments if (DocumentID != 0) { // Check out the document if (AutoCheck) { // Get original step Id int originalStepId = node.DocumentWorkflowStepID; // Get current step info WorkflowStepInfo si = WorkflowManager.GetStepInfo(node); if (si != null) { // Decide if full refresh is needed bool automaticPublish = wi.WorkflowAutoPublishChanges; // Document is published or archived or uses automatic publish or step is different than original (document was updated) fullRefresh = si.StepIsPublished || si.StepIsArchived || (automaticPublish && !si.StepIsPublished) || (originalStepId != node.DocumentWorkflowStepID); } using (CMSActionContext ctx = new CMSActionContext() { LogEvents = false }) { VersionManager.CheckOut(node, node.IsPublished, true); } } // Handle field attachment if (fieldAttachment) { // Extension of CMS file before saving string oldExtension = node.DocumentType; newAttachment = DocumentHelper.AddAttachment(node, AttachmentGUIDColumnName, Guid.Empty, Guid.Empty, ucFileUpload.PostedFile, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); // Update attachment field DocumentHelper.UpdateDocument(node, TreeProvider); // Different extension if ((oldExtension != null) && !oldExtension.EqualsCSafe(node.DocumentType, true)) { refreshTree = true; } } // Handle grouped and unsorted attachments else { // Grouped attachment if (AttachmentGroupGUID != Guid.Empty) { newAttachment = DocumentHelper.AddGroupedAttachment(node, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); } // Unsorted attachment else { newAttachment = DocumentHelper.AddUnsortedAttachment(node, AttachmentGUID, ucFileUpload.PostedFile, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); } // Log synchronization task if not under workflow if (wi == null) { DocumentSynchronizationHelper.LogDocumentChange(node, TaskTypeEnum.UpdateDocument, TreeProvider); } } // Check in the document if (AutoCheck) { using (CMSActionContext ctx = new CMSActionContext() { LogEvents = false }) { VersionManager.CheckIn(node, null, null); } } } // Temporary attachments if (FormGUID != Guid.Empty) { newAttachment = (DocumentAttachment)AttachmentInfoProvider.AddTemporaryAttachment(FormGUID, AttachmentGUIDColumnName, AttachmentGUID, AttachmentGroupGUID, ucFileUpload.PostedFile, SiteContext.CurrentSiteID, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize); } // Ensure properties update if ((newAttachment != null) && !InsertMode) { AttachmentGUID = newAttachment.AttachmentGUID; } if (newAttachment == null) { throw new Exception("The attachment hasn't been created since no DocumentID or FormGUID was supplied."); } } catch (Exception ex) { // Log the exception EventLogProvider.LogException("Content", "UploadAttachment", ex); message = ex.Message; } finally { string afterSaveScript = string.Empty; // Call aftersave javascript if exists if (!String.IsNullOrEmpty(AfterSaveJavascript)) { if ((message == string.Empty) && (newAttachment != null)) { string url = null; string safeName = URLHelper.GetSafeFileName(newAttachment.AttachmentName, SiteContext.CurrentSiteName); if (node != null) { SiteInfo si = SiteInfoProvider.GetSiteInfo(node.NodeSiteID); if (si != null) { bool usePermanent = DocumentURLProvider.UsePermanentUrls(si.SiteName); if (usePermanent) { url = ResolveUrl(AttachmentURLProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, safeName)); } else { url = ResolveUrl(AttachmentURLProvider.GetAttachmentUrl(safeName, node.NodeAliasPath)); } } } else { url = ResolveUrl(AttachmentURLProvider.GetAttachmentUrl(newAttachment.AttachmentGUID, safeName)); } // Calling javascript function with parameters attachments url, name, width, height if (!string.IsNullOrEmpty(AfterSaveJavascript)) { Hashtable obj = new Hashtable(); if (ImageHelper.IsImage(newAttachment.AttachmentExtension)) { obj[DialogParameters.IMG_URL] = url; obj[DialogParameters.IMG_TOOLTIP] = newAttachment.AttachmentName; obj[DialogParameters.IMG_WIDTH] = newAttachment.AttachmentImageWidth; obj[DialogParameters.IMG_HEIGHT] = newAttachment.AttachmentImageHeight; } else if (MediaHelper.IsFlash(newAttachment.AttachmentExtension)) { obj[DialogParameters.OBJECT_TYPE] = "flash"; obj[DialogParameters.FLASH_URL] = url; obj[DialogParameters.FLASH_EXT] = newAttachment.AttachmentExtension; obj[DialogParameters.FLASH_TITLE] = newAttachment.AttachmentName; obj[DialogParameters.FLASH_WIDTH] = DEFAULT_OBJECT_WIDTH; obj[DialogParameters.FLASH_HEIGHT] = DEFAULT_OBJECT_HEIGHT; } else if (MediaHelper.IsAudioVideo(newAttachment.AttachmentExtension)) { obj[DialogParameters.OBJECT_TYPE] = "audiovideo"; obj[DialogParameters.AV_URL] = url; obj[DialogParameters.AV_EXT] = newAttachment.AttachmentExtension; obj[DialogParameters.AV_WIDTH] = DEFAULT_OBJECT_WIDTH; obj[DialogParameters.AV_HEIGHT] = DEFAULT_OBJECT_HEIGHT; } else { obj[DialogParameters.LINK_URL] = url; obj[DialogParameters.LINK_TEXT] = newAttachment.AttachmentName; } // Calling javascript function with parameters attachments url, name, width, height afterSaveScript += ScriptHelper.GetScript(string.Format(@"{5} if (window.{0}) {{ window.{0}('{1}', '{2}', '{3}', '{4}', obj); }} else if((window.parent != null) && window.parent.{0}) {{ window.parent.{0}('{1}', '{2}', '{3}', '{4}', obj); }}", AfterSaveJavascript, url, newAttachment.AttachmentName, newAttachment.AttachmentImageWidth, newAttachment.AttachmentImageHeight, CMSDialogHelper.GetDialogItem(obj))); } } else { afterSaveScript += ScriptHelper.GetAlertScript(message); } } // Create attachment info string string attachmentInfo = ((newAttachment != null) && (newAttachment.AttachmentGUID != Guid.Empty) && (IncludeNewItemInfo)) ? String.Format("'{0}', ", newAttachment.AttachmentGUID) : ""; // Ensure message text message = TextHelper.EnsureLineEndings(message, " "); // Call function to refresh parent window afterSaveScript += ScriptHelper.GetScript(String.Format(@" if ((window.parent != null) && (/parentelemid={0}/i.test(window.location.href)) && (window.parent.InitRefresh_{0} != null)){{ window.parent.InitRefresh_{0}({1}, {2}, {3}, {4}); }}", ParentElemID, ScriptHelper.GetString(message.Trim()), (fullRefresh ? "true" : "false"), (refreshTree ? "true" : "false"), attachmentInfo + (InsertMode ? "'insert'" : "'update'"))); ScriptHelper.RegisterStartupScript(this, typeof(string), "afterSaveScript_" + ClientID, afterSaveScript); } }
/// <summary> /// Adds GUID field to form definition. /// </summary> private void CreateGUID() { bool success; try { if (FormInfo == null) { return; } // Create GUID field FormFieldInfo ffiGuid = new FormFieldInfo(); // Fill FormInfo object ffiGuid.Name = "ItemGUID"; ffiGuid.SetPropertyValue(FormFieldPropertyEnum.FieldCaption, "GUID"); ffiGuid.DataType = FieldDataType.Guid; ffiGuid.SetPropertyValue(FormFieldPropertyEnum.DefaultValue, string.Empty); ffiGuid.SetPropertyValue(FormFieldPropertyEnum.FieldDescription, String.Empty); ffiGuid.FieldType = FormFieldControlTypeEnum.CustomUserControl; ffiGuid.Settings["controlname"] = Enum.GetName(typeof(FormFieldControlTypeEnum), FormFieldControlTypeEnum.LabelControl).ToLowerCSafe(); ffiGuid.PrimaryKey = false; ffiGuid.System = true; ffiGuid.Visible = false; ffiGuid.Size = 0; ffiGuid.AllowEmpty = false; FormInfo.AddFormItem(ffiGuid); // Update definition dci.ClassFormDefinition = FormInfo.GetXmlDefinition(); using (CMSActionContext context = new CMSActionContext()) { // Disable logging into event log context.LogEvents = false; DataClassInfoProvider.SetDataClassInfo(dci); } // Clear the default queries QueryInfoProvider.ClearDefaultQueries(dci, true, false); // Clear the object type hashtable AbstractProviderDictionary.ReloadDictionaries(className, true); // Clear the classes hashtable AbstractProviderDictionary.ReloadDictionaries("cms.class", true); // Clear class strucures ClassStructureInfo.Remove(className, true); // Ensure GUIDs for all items using (CMSActionContext ctx = new CMSActionContext()) { ctx.UpdateSystemFields = false; ctx.LogSynchronization = false; DataSet dsItems = CustomTableItemProvider.GetItems(className); if (!DataHelper.DataSourceIsEmpty(dsItems)) { foreach (DataRow dr in dsItems.Tables[0].Rows) { CustomTableItem item = CustomTableItem.New(className, dr); item.ItemGUID = Guid.NewGuid(); item.Update(); } } } // Log event UserInfo currentUser = MembershipContext.AuthenticatedUser; EventLogProvider.LogEvent(EventType.INFORMATION, "Custom table", "GENERATEGUID", string.Format(ResHelper.GetAPIString("customtable.GUIDGenerated", "Field 'ItemGUID' for custom table '{0}' was created and GUID values were generated."), dci.ClassName), null, currentUser.UserID, currentUser.UserName); success = true; } catch (Exception ex) { success = false; FieldEditor.ShowError(GetString("customtable.ErrorGUID")); // Log event EventLogProvider.LogException("Custom table", "GENERATEGUID", ex); } if (success) { URLHelper.Redirect(URLHelper.AddParameterToUrl(RequestContext.CurrentURL, "gen", "1")); } }
/// <summary> /// Reload data. /// </summary> public override void ReloadData(bool forceLoad) { if ((GraphImageWidth != 0) && (ComputedWidth == 0)) { // Graph width is computed no need to create graph return; } this.Visible = true; // Indicaates whether exception was throw during data loading bool errorOccurred = false; ReportInfo ri = null; try { this.ReportTableName = this.Parameter; this.EnsureTableInfo(); this.EnsureChildControls(); //Test security if (TableInfo != null) { ri = ReportInfoProvider.GetReportInfo(TableInfo.TableReportID); if (ri != null) { if (ri.ReportAccess != ReportAccessEnum.All) { if (!CMSContext.CurrentUser.IsAuthenticated()) { this.Visible = false; return; } } //Set default parametrs directly if not set if (this.ReportParameters == null) { FormInfo fi = new FormInfo(ri.ReportParameters); // Get datarow with required columns this.ReportParameters = fi.GetDataRow(); fi.LoadDefaultValues(this.ReportParameters); } ApplyTimeParameters(); } } // Only use base parameters in case of stored procedure if (this.QueryIsStoredProcedure) { this.AllParameters = SpecialFunctions.ConvertDataRowToParams(this.ReportParameters, null); } // Load data DataSet ds = this.LoadData(); // If no data load, set empty dataset if (DataHelper.DataSourceIsEmpty(ds)) { string noRecordText = ValidationHelper.GetString(TableInfo.TableSettings["QueryNoRecordText"], String.Empty); if (noRecordText != String.Empty) { GridViewObject.Visible = false; lblInfo.Text = noRecordText; lblInfo.Visible = true; return; } this.Visible = false; } else { GridViewObject.Visible = true; // Resolve macros in column names int i = 0; foreach (DataColumn dc in ds.Tables[0].Columns) { if (dc.ColumnName == "Column" + ((int)(i + 1)).ToString()) { dc.ColumnName = ResolveMacros(ds.Tables[0].Rows[0][i].ToString()); } else { dc.ColumnName = ResolveMacros(dc.ColumnName); } i++; } // Resolve macros in dataset foreach (DataRow dr in ds.Tables[0].Rows) { foreach (DataColumn dc in ds.Tables[0].Columns) { if (dc.DataType.FullName.ToLower() == "system.string") { dr[dc.ColumnName] = ResolveMacros(ValidationHelper.GetString(dr[dc.ColumnName], "")); } } } } ApplyStyles(); // Databind to gridview control GridViewObject.DataSource = ds; this.EnsurePageIndex(); GridViewObject.DataBind(); if ((TableFirstColumnWidth != Unit.Empty) && (GridViewObject.Rows.Count > 0)) { GridViewObject.Rows[0].Cells[0].Width = TableFirstColumnWidth; } } catch (Exception ex) { // Display error message, if data load fail lblError.Visible = true; lblError.Text = "[ReportTable.ascx] Error loading the data: " + ex.Message; EventLogProvider ev = new EventLogProvider(); ev.LogEvent("Report table", "E", ex); errorOccurred = true; } // Export data if ((ri != null) && (!errorOccurred)) { ProcessExport(ValidationHelper.GetCodeName(ri.ReportDisplayName)); } }
/// <summary> /// Provides operations necessary to create and store new physical file. /// </summary> private void HandlePhysicalFilesUpload() { string message = string.Empty; try { // Check the allowed extensions CheckAllowedExtensions(); // Prepare the file name string extension = Path.GetExtension(ucFileUpload.FileName); string fileName = TargetFileName; if (String.IsNullOrEmpty(fileName)) { fileName = Path.GetFileName(ucFileUpload.FileName); } else if (!fileName.Contains(".")) { fileName += extension; } // Prepare the path if (String.IsNullOrEmpty(TargetFolderPath)) { TargetFolderPath = "~/"; } string filePath = TargetFolderPath; // Try to map virtual and relative path to server try { if (!Path.IsPathRooted(filePath)) { filePath = Server.MapPath(filePath); } } catch { } filePath = DirectoryHelper.CombinePath(filePath, fileName); // Ensure directory DirectoryHelper.EnsureDiskPath(filePath, SystemContext.WebApplicationPhysicalPath); // Ensure unique file name if (String.IsNullOrEmpty(TargetFileName) && File.Exists(filePath)) { int index = 0; string basePath = filePath.Substring(0, filePath.Length - extension.Length); string newPath = filePath; do { index++; newPath = basePath + "_" + index + extension; } while (File.Exists(newPath)); filePath = newPath; } // Upload file if (ImageHelper.IsImage(extension) && ((ResizeToHeight > 0) || (ResizeToWidth > 0) || (ResizeToMaxSideSize > 0))) { byte[] data = ucFileUpload.FileBytes; // Resize the image ImageHelper img = new ImageHelper(data); int[] newSize = ImageHelper.EnsureImageDimensions(ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize, img.ImageWidth, img.ImageHeight); if ((newSize[0] != img.ImageWidth) || (newSize[1] != img.ImageHeight)) { data = img.GetResizedImageData(newSize[0], newSize[1]); } // Write to file File.WriteAllBytes(filePath, data); } else { File.WriteAllBytes(filePath, ucFileUpload.FileBytes); } } catch (Exception ex) { // Log the exception EventLogProvider.LogException("Uploader", "UploadPhysicalFile", ex); message = ex.Message; } finally { string afterSaveScript = string.Empty; if (!String.IsNullOrEmpty(message)) { afterSaveScript = "setTimeout(\"alert(" + ScriptHelper.GetString(ScriptHelper.GetString(message), false) + ")\", 1);"; } else { if (!string.IsNullOrEmpty(AfterSaveJavascript)) { afterSaveScript = String.Format( @" if (window.{0} != null) {{ window.{0}(files) }} else if ((window.parent != null) && (window.parent.{0} != null)) {{ window.parent.{0}(files) }} ", AfterSaveJavascript ); } else { afterSaveScript += "if ((window.parent != null) && (/parentelemid=" + ParentElemID + "/i.test(window.location.href)) && (window.parent.InitRefresh_" + ParentElemID + " != null)){window.parent.InitRefresh_" + ParentElemID + "(" + ScriptHelper.GetString(message.Trim()) + ", false, false);}"; } } afterSaveScript = ScriptHelper.GetScript(afterSaveScript); ScriptHelper.RegisterStartupScript(this, typeof(string), "afterSaveScript_" + ClientID, afterSaveScript); } }
protected void btnOK_Click(object sender, EventArgs e) { string result = new Validator().NotEmpty(rfvDisplayName, rfvDisplayName.ErrorMessage).NotEmpty(rfvCodeName, rfvCodeName.ErrorMessage).NotEmpty(rfvURL, rfvURL.ErrorMessage) .IsCodeName(txtCodeName.Text, GetString("general.invalidcodename")) .Result; // Get the object WebFarmServerInfo wi = WebFarmServerInfoProvider.GetWebFarmServerInfo(serverid) ?? new WebFarmServerInfo(); // Check license web farm server limit if (String.IsNullOrEmpty(result)) { LicenseKeyInfo lki = LicenseHelper.CurrentLicenseInfo; if (lki == null) { return; } // Only if server is enabled if (chkEnabled.Checked) { // Enabling or new server as action insert VersionActionEnum action = ((wi.ServerID > 0) && wi.ServerEnabled) ? VersionActionEnum.Edit : VersionActionEnum.Insert; if (!lki.CheckServerCount(WebSyncHelperClass.ServerCount, action)) { result = GetString("licenselimitation.infopagemessage"); } // Log the message if (!String.IsNullOrEmpty(result)) { EventLogProvider eventLog = new EventLogProvider(); string message = GetString("licenselimitation.serversexceeded"); eventLog.LogEvent(EventLogProvider.EVENT_TYPE_WARNING, DateTime.Now, "WebFarms", LicenseHelper.LICENSE_LIMITATION_EVENTCODE, URLHelper.CurrentURL, message); } } } if (result == "") { wi.ServerID = serverid; wi.ServerDisplayName = txtDisplayName.Text; wi.ServerName = txtCodeName.Text; wi.ServerURL = txtURL.Text; wi.ServerEnabled = chkEnabled.Checked; try { WebFarmServerInfoProvider.SetWebFarmServerInfo(wi); // Clear server list URLHelper.Redirect("WebFarm_Server_Edit.aspx?serverid=" + wi.ServerID + "&saved=1"); } catch (Exception ex) { lblError.Text = ex.Message.Replace("%%name%%", wi.ServerName); lblError.Visible = true; lblInfo.Visible = false; } } else { lblError.Text = result; lblError.Visible = true; lblInfo.Visible = false; } }
private void HandleMetaFileUpload() { string message = string.Empty; MetaFileInfo mfi = null; try { // Check the allowed extensions CheckAllowedExtensions(); if (InsertMode) { // Create new meta file mfi = new MetaFileInfo(FileUploadControl.PostedFile, ObjectID, ObjectType, Category); mfi.MetaFileSiteID = SiteID; } else { if (MetaFileID > 0) { mfi = MetaFileInfoProvider.GetMetaFileInfo(MetaFileID); } else { DataSet ds = MetaFileInfoProvider.GetMetaFilesWithoutBinary(ObjectID, ObjectType, Category, null, null); if (!DataHelper.DataSourceIsEmpty(ds)) { mfi = new MetaFileInfo(ds.Tables[0].Rows[0]); } } if (mfi != null) { string fileExt = Path.GetExtension(FileUploadControl.FileName); // Init the MetaFile data mfi.MetaFileName = URLHelper.GetSafeFileName(FileUploadControl.FileName, null); mfi.MetaFileExtension = fileExt; mfi.MetaFileSize = Convert.ToInt32(FileUploadControl.PostedFile.InputStream.Length); mfi.MetaFileMimeType = MimeTypeHelper.GetMimetype(fileExt); mfi.InputStream = FileUploadControl.PostedFile.InputStream; // Set image properties if (ImageHelper.IsImage(mfi.MetaFileExtension)) { // Make MetaFile binary load from InputStream mfi.MetaFileBinary = null; ImageHelper ih = new ImageHelper(mfi.MetaFileBinary); mfi.MetaFileImageHeight = ih.ImageHeight; mfi.MetaFileImageWidth = ih.ImageWidth; } } } if (mfi != null) { // Save file to the database MetaFileInfoProvider.SetMetaFileInfo(mfi); } } catch (Exception ex) { // Log the exception EventLogProvider.LogException("Uploader", "UploadMetaFile", ex); message = ex.Message; } finally { string afterSaveScript = string.Empty; if (String.IsNullOrEmpty(message)) { if (!string.IsNullOrEmpty(AfterSaveJavascript)) { afterSaveScript = String.Format( @" if (window.{0} != null) {{ window.{0}(files) }} else if ((window.parent != null) && (window.parent.{0} != null)) {{ window.parent.{0}(files) }} ", AfterSaveJavascript ); } else { afterSaveScript = String.Format(@" if ((window.parent != null) && (/parentelemid={0}/i.test(window.location.href)) && (window.parent.InitRefresh_{0})) {{ window.parent.InitRefresh_{0}('{1}', false, false, {2}); }} else {{ if ('{1}' != '') {{ alert('{1}'); }} }}", ParentElemID, ScriptHelper.GetString(message.Trim(), false), mfi.MetaFileID.ToString() + (InsertMode ? ",'insert'" : ",'update'")); } } else { afterSaveScript += ScriptHelper.GetAlertScript(message, false); } ScriptHelper.RegisterStartupScript(this, typeof(string), "afterSaveScript_" + ClientID, afterSaveScript, true); } }
/// <summary> /// Reload data. /// </summary> public override void ReloadData(bool forceLoad) { try { // Load value info object ReportValueInfo rvi = ValueInfo; if (rvi != null) { //Test security ReportInfo ri = ReportInfoProvider.GetReportInfo(rvi.ValueReportID); if (ri.ReportAccess != ReportAccessEnum.All) { if (!CMSContext.CurrentUser.IsAuthenticated()) { this.Visible = false; return; } } ContextResolver resolver = CMSContext.CurrentResolver; // Resolve dynamic data macros if (DynamicMacros != null) { for (int i = 0; i <= this.DynamicMacros.GetUpperBound(0); i++) { resolver.AddDynamicParameter(DynamicMacros[i, 0], DynamicMacros[i, 1]); } } this.QueryIsStoredProcedure = rvi.ValueQueryIsStoredProcedure; this.QueryText = resolver.ResolveMacros(rvi.ValueQuery); //Set default parametrs directly if not set if (this.ReportParameters == null) { if (ri != null) { FormInfo fi = new FormInfo(ri.ReportParameters); // Get datarow with required columns this.ReportParameters = fi.GetDataRow(); fi.LoadDefaultValues(this.ReportParameters); } } } // Only use base parameters in case of stored procedure if (this.QueryIsStoredProcedure) { this.AllParameters = SpecialFunctions.ConvertDataRowToParams(this.ReportParameters, null); } // Load data DataSet ds = this.LoadData(); // If datasource is emptry, create empty dataset if (!DataHelper.DataSourceIsEmpty(ds)) { // Set literal text string value = rvi.ValueFormatString; if ((value == null) || (value == "")) { value = ValidationHelper.GetString(ds.Tables[0].Rows[0][0], ""); } else { value = string.Format(value, ds.Tables[0].Rows[0].ItemArray); } lblValue.Text = HTMLHelper.HTMLEncode(ResolveMacros(value)); } } catch (Exception ex) { // Display error message, if data load fail lblError.Visible = true; lblError.Text = "[ReportValue.ascx] Error loading the data: " + ex.Message; EventLogProvider ev = new EventLogProvider(); ev.LogEvent("Report value", "E", ex); } }
private void LbSubmit_Click(object sender, EventArgs e) { if (this.Page.IsValid) { int userId = GetResetRequestID(); // Check if password expired if (pwdExp > 0) { UserInfo ui = UserInfoProvider.GetUserInfo(userId); if (!UserInfoProvider.IsUserPasswordDifferent(ui, txtNewPassword.Text)) { ShowError(GetString("passreset.newpasswordrequired")); return; } } // Get e-mail address of sender string emailFrom = DataHelper.GetNotEmpty(SendEmailFrom, SettingsKeyInfoProvider.GetStringValue(siteName + ".CMSSendPasswordEmailsFrom")); // Try to reset password and show result to user bool success; string resultText = AuthenticationHelper.ResetPassword(hash, time, userId, interval, txtNewPassword.Text, "Reset password control", emailFrom, siteName, null, out success, InvalidRequestText, ExceededIntervalText); if (success) { try { var userInfo = UserInfoProvider.GetFullUserInfo(userId); var userName = userInfo.UserName; var result = ssoClient.SSOCustomerUpdatePasswordByUserName(PersonifyVendorName, PersonifyVendorPassword, userName, txtNewPassword.Text); if (!result.Result) { success = false; if (result.Errors != null && result.Errors.Any()) { resultText = result.Errors.First(); } else { resultText = "Unknown SSO Error Updating Password."; } EventLogProvider.LogEvent(EventType.WARNING, "CMSWebParts_Personify_ChangePassword", resultText, eventDescription: string.Format("Failed to update user credentials in personify SSO with username: {0}", userName), userId: userId, userName: userName, siteId: SiteContext.CurrentSiteID, eventTime: DateTime.Now); } } catch (Exception ex) { success = false; resultText = "Program Error Updating SSO Password"; EventLogProvider.LogException("CMSWebParts_Personify_ChangePassword", resultText, ex); } } // If password reset was successful if (success) { ClearResetRequestID(); // Redirect to specified URL if (!string.IsNullOrEmpty(RedirectUrl)) { URLHelper.Redirect(RedirectUrl); } // Get proper text ShowConfirmation(DataHelper.GetNotEmpty(SuccessText, resultText)); pnlReset.Visible = false; } else { ShowError(resultText); } } }
public void RaisePostBackEvent(string eventArgument) { CurrentUserInfo currentUser = CMSContext.CurrentUser; // Current Node ID int nodeId = ValidationHelper.GetInteger(Param1, 0); TreeProvider tree = new TreeProvider(currentUser); EventLogProvider log = new EventLogProvider(); string documentName = string.Empty; string action = Action.ToLower(); string siteName = CMSContext.CurrentSiteName; // Process the request switch (action) { case "refresh": treeContent.NodeID = nodeId; AddScript("currentNodeId = " + nodeId + ";\n"); break; case "moveup": case "movedown": case "movetop": case "movebottom": // Move the document up (document order) try { if (nodeId == 0) { AddAlert(GetString("ContentRequest.ErrorMissingSource")); return; } // Get document to move TreeNode node = tree.SelectSingleNode(nodeId); // Check the permissions for document if (currentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Modify) == AuthorizationResultEnum.Allowed) { switch (action) { case "moveup": node = tree.MoveNodeUp(nodeId); break; case "movedown": node = tree.MoveNodeDown(nodeId); break; case "movetop": node = tree.SelectSingleNode(nodeId); tree.SetNodeOrder(nodeId, DocumentOrderEnum.First); break; case "movebottom": node = tree.SelectSingleNode(nodeId); tree.SetNodeOrder(nodeId, DocumentOrderEnum.Last); break; } if (node != null) { // Log the synchronization tasks for the entire tree level if (SettingsKeyProvider.GetBoolValue(siteName + ".CMSStagingLogChanges")) { // Log the synchronization tasks for the entire tree level DocumentSynchronizationHelper.LogDocumentChangeOrder(siteName, node.NodeAliasPath, tree); } // Select the document in the tree documentName = node.DocumentName; treeContent.ExpandNodeID = node.NodeParentID; treeContent.NodeID = node.NodeID; AddScript("currentNodeId = " + node.NodeID + ";\n"); } else { AddAlert(GetString("ContentRequest.MoveFailed")); } } else { // Select the document in the tree treeContent.NodeID = nodeId; AddAlert(GetString("ContentRequest.MoveDenied")); } } catch (Exception ex) { log.LogEvent(EventLogProvider.EVENT_TYPE_ERROR, DateTime.Now, "Content", "MOVE", currentUser.UserID, currentUser.UserName, nodeId, documentName, HTTPHelper.GetUserHostAddress(), EventLogProvider.GetExceptionLogMessage(ex), CMSContext.CurrentSite.SiteID, HTTPHelper.GetAbsoluteUri()); AddAlert(GetString("ContentRequest.MoveFailed") + " : " + ex.Message); } break; case "setculture": // Set the preferred culture code try { // Set the culture code string language = ValidationHelper.GetString(Param2, ""); if (!string.IsNullOrEmpty(language)) { CMSContext.PreferredCultureCode = language; } // Refresh the document if (nodeId > 0) { treeContent.NodeID = nodeId; AddScript("SelectNode(" + nodeId + "); \n"); } } catch (Exception ex) { log.LogEvent(EventLogProvider.EVENT_TYPE_ERROR, DateTime.Now, "Content", "SETCULTURE", currentUser.UserID, currentUser.UserName, nodeId, documentName, HTTPHelper.GetUserHostAddress(), EventLogProvider.GetExceptionLogMessage(ex), CMSContext.CurrentSite.SiteID, HTTPHelper.GetAbsoluteUri()); AddAlert(GetString("ContentRequest.ErrorChangeLanguage")); } break; // Sorting case "sortalphaasc": case "sortalphadesc": case "sortdateasc": case "sortdatedesc": // Set the preferred culture code try { // Get document to sort TreeNode node = tree.SelectSingleNode(nodeId); // Check the permissions for document if ((currentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.Modify) == AuthorizationResultEnum.Allowed) && (currentUser.IsAuthorizedPerDocument(node, NodePermissionsEnum.ExploreTree) == AuthorizationResultEnum.Allowed)) { switch (action) { case "sortalphaasc": tree.OrderNodesAlphabetically(nodeId, true); break; case "sortalphadesc": tree.OrderNodesAlphabetically(nodeId, false); break; case "sortdateasc": tree.OrderNodesByDate(nodeId, true); break; case "sortdatedesc": tree.OrderNodesByDate(nodeId, false); break; } // Log the synchronization tasks for the entire tree level if (SettingsKeyProvider.GetBoolValue(siteName + ".CMSStagingLogChanges")) { // Log the synchronization tasks for the entire tree level string fakeAlias = node.NodeAliasPath.TrimEnd('/') + "/child"; DocumentSynchronizationHelper.LogDocumentChangeOrder(siteName, fakeAlias, tree); } } else { AddAlert(GetString("ContentRequest.SortDenied")); } // Refresh the tree if (nodeId > 0) { treeContent.ExpandNodeID = nodeId; treeContent.NodeID = nodeId; AddScript("SelectNode(" + nodeId + "); \n"); } } catch (Exception ex) { log.LogEvent(EventLogProvider.EVENT_TYPE_ERROR, DateTime.Now, "Content", "SORT", currentUser.UserID, currentUser.UserName, nodeId, documentName, HTTPHelper.GetUserHostAddress(), EventLogProvider.GetExceptionLogMessage(ex), CMSContext.CurrentSite.SiteID, HTTPHelper.GetAbsoluteUri()); AddAlert(GetString("ContentRequest.ErrorSort")); } break; } // Maintain scrollbar position string script = @"var elm = jQuery('#handle_" + nodeId + @"'); var pnl = jQuery('#" + pnlTreeArea.ClientID + @"'); var origScroll = " + ScrollPosition + @"; var elmOff = elm.offset(); var elmPos = (elmOff == null) ? 0 : elmOff.top; var scroll = ((elmPos < origScroll) || (elmPos > (origScroll + pnl.height()))); pnl.scrollTop(origScroll); if(scroll){pnl.animate({ scrollTop: elmPos - 20 }, 300);};"; ScriptHelper.RegisterStartupScript(Page, typeof(string), "MaintainScrollbar", script, true); }
private void HandleError(Exception exception) { ErrorControl.Report(exception); EventLogProvider.LogException("Facebook integration", "MappingFormControl", exception); }
protected void ctrlImport_OnFinished(object sender, EventArgs e) { try { // Convert default culture if (!siteType.SelectTemplate) { TreeProvider tree = new TreeProvider(CMSContext.CurrentUser); tree.ChangeSiteDefaultCulture(SiteName, Culture, "en-US"); // Change root GUID TreeNode root = DocumentHelper.GetDocument(SiteName, "/", Culture, false, "cms.root", null, null, 1, false, null, tree); if (root != null) { root.NodeGUID = Guid.NewGuid(); DocumentHelper.UpdateDocument(root, tree); } } } catch (Exception ex) { EventLogProvider ev = new EventLogProvider(); ev.LogEvent("NewSiteWizard", "FINISH", ex); } finally { if (ImportManager.Settings.ProcessCanceled) { NextButton.Enabled = CancelButton.Enabled = false; mImportCanceled = true; lblProgress.Text = "<strong>" + ResHelper.GetAPIString("ImportSite.ImportCanceled", "Import process has been cancelled.") + "</strong>"; } else { if (!ImportManager.Settings.IsWarning() && !ImportManager.Settings.IsError()) { PreviousButton.Visible = false; CultureHelper.SetPreferredCulture(Culture); if (siteType.SelectTemplate) { // Done finishSite.Domain = Domain; wzdImport.ActiveStepIndex = 7; } else { selectMaster.SiteName = SiteName; wzdImport.ActiveStepIndex += 1; selectMaster.ReloadData(); } } } // Stop the timer string script = "StopSelectionTimer();"; ltlScriptAfter.Text += ScriptHelper.GetScript(script); } }
/// <summary> /// Save selected field. /// </summary> private void SaveSelectedField() { // FormFieldInfo structure with data from updated form FormFieldInfo ffiUpdated = null; // FormCategoryInfo structure with data from updated form FormCategoryInfo fciUpdated = null; // Determines whether it is a new attribute (or attribute to update) bool isNewItem = false; string errorMessage = null; DataClassInfo dci = null; WebPartInfo wpi = null; // Variables for changes in DB tables string tableName = null; string oldColumnName = null; string newColumnName = null; string newColumnSize = null; string newColumnType = null; string newColumnDefaultValue = null; // No default value bool newColumnAllowNull = true; if (!IsAlternativeForm) { switch (mMode) { case FieldEditorModeEnum.WebPartProperties: // Fill WebPartInfo structure with data from database wpi = WebPartInfoProvider.GetWebPartInfo(mWebPartId); break; case FieldEditorModeEnum.ClassFormDefinition: case FieldEditorModeEnum.BizFormDefinition: case FieldEditorModeEnum.SystemTable: case FieldEditorModeEnum.CustomTable: // Fill ClassInfo structure with data from database dci = DataClassInfoProvider.GetDataClass(mClassName); if (dci != null) { // Set table name tableName = dci.ClassTableName; } else { lblError.Visible = true; lblError.ResourceString = "fieldeditor.notablename"; return; } break; } } // Load current xml form definition LoadFormDefinition(); if (SelectedItemType == FieldEditorSelectedItemEnum.Field) { // Fill FormFieldInfo structure with original data ffi = fi.GetFormField(SelectedItemName); // Fill FormFieldInfo structure with updated form data ffiUpdated = FillFormFieldInfoStructure(ffi); // Determine whether it is a new attribute or not isNewItem = (ffi == null); // Check if the attribute name already exists if (isNewItem || (ffi.Name.ToLower() != ffiUpdated.Name.ToLower())) { columnNames = fi.GetColumnNames(); if (columnNames != null) { foreach (string colName in columnNames) { // If name already exists if (ffiUpdated.Name.ToLower() == colName.ToLower()) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorExistingColumnName"; return; } } } // Check column name duplicity in JOINed tables if (!IsSystemFieldSelected) { // Check whether current column already exists in 'View_CMS_Tree_Joined' if (IsDocumentType && DocumentHelper.ColumnExistsInSystemTable(ffiUpdated.Name)) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorExistingColumnInJoinedTable"; return; } // Check whether current column is uniquie in tables used to create views - applied only for system tables if ((Mode == FieldEditorModeEnum.SystemTable) && FormHelper.ColumnExistsInView(mClassName, ffiUpdated.Name)) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorExistingColumnInJoinedTable"; return; } } } // New node if (isNewItem) { ffiUpdated.PrimaryKey = this.IsPrimaryField; newColumnName = ffiUpdated.Name; newColumnAllowNull = ffiUpdated.AllowEmpty; // Set implicit default value if (!(newColumnAllowNull) && (string.IsNullOrEmpty(ffiUpdated.DefaultValue))) { if (!this.DevelopmentMode) { switch (ffiUpdated.DataType) { case FormFieldDataTypeEnum.Integer: case FormFieldDataTypeEnum.LongInteger: case FormFieldDataTypeEnum.Decimal: case FormFieldDataTypeEnum.Boolean: newColumnDefaultValue = "0"; break; case FormFieldDataTypeEnum.Text: case FormFieldDataTypeEnum.LongText: case FormFieldDataTypeEnum.DocumentAttachments: newColumnDefaultValue = ""; break; case FormFieldDataTypeEnum.DateTime: newColumnDefaultValue = new DateTime(1970, 1, 1, 0, 0, 0).ToString(); break; case FormFieldDataTypeEnum.File: case FormFieldDataTypeEnum.GUID: // 32 digits, empty Guid newColumnDefaultValue = Guid.Empty.ToString(); break; case FormFieldDataTypeEnum.Binary: newColumnDefaultValue = null; break; } } } // Check if default value is in required format else if (!string.IsNullOrEmpty(ffiUpdated.DefaultValue)) { // If default value is macro, don't try to ensure the type if (!ffiUpdated.IsMacro) { switch (ffiUpdated.DataType) { case FormFieldDataTypeEnum.Integer: try { int i = Int32.Parse(ffiUpdated.DefaultValue); newColumnDefaultValue = i.ToString(); } catch { newColumnDefaultValue = "0"; errorMessage = GetString("TemplateDesigner.ErrorDefaultValueInteger"); } break; case FormFieldDataTypeEnum.LongInteger: try { long longInt = long.Parse(ffiUpdated.DefaultValue); newColumnDefaultValue = longInt.ToString(); } catch { newColumnDefaultValue = "0"; errorMessage = GetString("TemplateDesigner.ErrorDefaultValueLongInteger"); } break; case FormFieldDataTypeEnum.Decimal: if (ValidationHelper.IsDouble(ffiUpdated.DefaultValue)) { newColumnDefaultValue = FormHelper.GetDoubleValueInDBCulture(ffiUpdated.DefaultValue); } else { newColumnDefaultValue = "0"; errorMessage = GetString("TemplateDesigner.ErrorDefaultValueDouble"); } break; case FormFieldDataTypeEnum.DateTime: if ((ffiUpdated.DefaultValue.ToLower() == DateTimePicker.DATE_TODAY.ToLower()) || (ffiUpdated.DefaultValue.ToLower() == DateTimePicker.TIME_NOW.ToLower())) { newColumnDefaultValue = ffiUpdated.DefaultValue; } else { try { DateTime dat = DateTime.Parse(ffiUpdated.DefaultValue); newColumnDefaultValue = dat.ToString(); } catch { newColumnDefaultValue = DateTime.Now.ToString(); errorMessage = GetString("TemplateDesigner.ErrorDefaultValueDateTime"); } } break; case FormFieldDataTypeEnum.File: case FormFieldDataTypeEnum.GUID: try { Guid g = new Guid(ffiUpdated.DefaultValue); newColumnDefaultValue = g.ToString(); } catch { newColumnDefaultValue = Guid.Empty.ToString(); errorMessage = GetString("TemplateDesigner.ErrorDefaultValueGuid"); } break; case FormFieldDataTypeEnum.LongText: case FormFieldDataTypeEnum.Text: case FormFieldDataTypeEnum.Boolean: newColumnDefaultValue = ffiUpdated.DefaultValue; break; } } } // Set column type and size LoadColumnTypeAndSize(ffiUpdated.DataType, ffiUpdated.Size, ref newColumnType, ref newColumnSize); if (string.IsNullOrEmpty(errorMessage)) { if (!IsAlternativeForm) { switch (mMode) { case FieldEditorModeEnum.ClassFormDefinition: case FieldEditorModeEnum.BizFormDefinition: case FieldEditorModeEnum.SystemTable: case FieldEditorModeEnum.CustomTable: // Add new column to specified table try { string newDBDefaultValue = null; // Check if it is not a macro if (ffiUpdated.IsMacro) { newDBDefaultValue = newColumnDefaultValue; } else { switch (ffiUpdated.DataType) { case FormFieldDataTypeEnum.Decimal: newDBDefaultValue = FormHelper.GetDoubleValueInDBCulture(newColumnDefaultValue); break; case FormFieldDataTypeEnum.DateTime: newDBDefaultValue = FormHelper.GetDateTimeValueInDBCulture(newColumnDefaultValue); break; default: newDBDefaultValue = newColumnDefaultValue; break; } } if (!ffiUpdated.External) { if (this.DevelopmentMode) { TableManager.AddTableColumn(tableName, newColumnName, newColumnType, newColumnAllowNull, newDBDefaultValue, false); } else { TableManager.AddTableColumn(tableName, newColumnName, newColumnType, newColumnAllowNull, newDBDefaultValue); } // Recreate the table PK constraint if (IsPrimaryField) { int pos = 0; FormFieldInfo[] pkFields = fi.GetFields(true, true, false, true); string[] primaryKeys = new string[pkFields.Length + 1]; foreach (FormFieldInfo pk in pkFields) { if (pk != null) { primaryKeys[pos++] = "[" + pk.Name + "]"; } } primaryKeys[pos] = "[" + newColumnName + "]"; TableManager.RecreatePKConstraint(tableName, primaryKeys, null); } } } catch (Exception ex) { lblError.Visible = true; lblError.Text = ex.Message; return; } break; } } } // Some error has occurred else { lblError.Visible = true; lblError.Text = errorMessage; return; } } // Existing node else { // Get info whether it is a primary key or system fild ffiUpdated.PrimaryKey = ffi.PrimaryKey; // If attribute is a primary key if (ffi.PrimaryKey) { // Check if the attribute type is integer number if (ffiUpdated.DataType != FormFieldDataTypeEnum.Integer) { errorMessage += GetString("TemplateDesigner.ErrorPKNotInteger") + " "; } // Check if allow empty is disabled if (ffiUpdated.AllowEmpty) { errorMessage += GetString("TemplateDesigner.ErrorPKAllowsNulls") + " "; } // Check that the field type is label string labelControlName = Enum.GetName(typeof(FormFieldControlTypeEnum), FormFieldControlTypeEnum.LabelControl).ToLower(); if ((ffiUpdated.FieldType != FormFieldControlTypeEnum.LabelControl) && ((ffiUpdated.FieldType != FormFieldControlTypeEnum.CustomUserControl) && (ffiUpdated.Settings["controlname"].ToString().ToLower() != labelControlName))) { errorMessage += GetString("TemplateDesigner.ErrorPKisNotLabel") + " "; } // Some error has occurred if (!string.IsNullOrEmpty(errorMessage)) { lblError.Visible = true; lblError.Text = GetString("TemplateDesigner.ErrorPKThisIsPK") + " " + errorMessage; return; } } // If table column update is needed if (((ffi.PrimaryKey) && (ffi.Name != ffiUpdated.Name)) || ((!ffi.PrimaryKey) && ((ffi.Name != ffiUpdated.Name) || (ffi.DataType != ffiUpdated.DataType) || (ffi.AllowEmpty != ffiUpdated.AllowEmpty) || (ffi.Size != ffiUpdated.Size) || ((ffi.DefaultValue != ffiUpdated.DefaultValue) || (ffiUpdated.DataType == FormFieldDataTypeEnum.Decimal))) ) ) { // Set variables needed for changes in DB oldColumnName = ffi.Name; newColumnName = ffiUpdated.Name; newColumnAllowNull = ffiUpdated.AllowEmpty; // Set implicit default value if (!(newColumnAllowNull) && (string.IsNullOrEmpty(ffiUpdated.DefaultValue))) { switch (ffiUpdated.DataType) { case FormFieldDataTypeEnum.Integer: case FormFieldDataTypeEnum.LongInteger: case FormFieldDataTypeEnum.Decimal: case FormFieldDataTypeEnum.Boolean: newColumnDefaultValue = "0"; break; case FormFieldDataTypeEnum.Text: case FormFieldDataTypeEnum.LongText: newColumnDefaultValue = ""; break; case FormFieldDataTypeEnum.DateTime: newColumnDefaultValue = DateTime.Now.ToString(); break; case FormFieldDataTypeEnum.File: case FormFieldDataTypeEnum.GUID: // 32 digits, empty Guid newColumnDefaultValue = Guid.Empty.ToString(); break; case FormFieldDataTypeEnum.Binary: newColumnDefaultValue = null; break; } } // Check if default value is in required format else if (!string.IsNullOrEmpty(ffiUpdated.DefaultValue)) { // If default value is macro, don't try to ensure the type if (!ffiUpdated.IsMacro) { switch (ffiUpdated.DataType) { case FormFieldDataTypeEnum.Integer: try { int i = Int32.Parse(ffiUpdated.DefaultValue); newColumnDefaultValue = i.ToString(); } catch { newColumnDefaultValue = "0"; errorMessage = GetString("TemplateDesigner.ErrorDefaultValueInteger"); } break; case FormFieldDataTypeEnum.LongInteger: try { long longInt = long.Parse(ffiUpdated.DefaultValue); newColumnDefaultValue = longInt.ToString(); } catch { newColumnDefaultValue = "0"; errorMessage = GetString("TemplateDesigner.ErrorDefaultValueLongInteger"); } break; case FormFieldDataTypeEnum.Decimal: if (ValidationHelper.IsDouble(ffiUpdated.DefaultValue)) { newColumnDefaultValue = FormHelper.GetDoubleValueInDBCulture(ffiUpdated.DefaultValue); } else { newColumnDefaultValue = "0"; errorMessage = GetString("TemplateDesigner.ErrorDefaultValueDouble"); } break; case FormFieldDataTypeEnum.DateTime: if ((ffiUpdated.DefaultValue.ToLower() == DateTimePicker.DATE_TODAY.ToLower()) || (ffiUpdated.DefaultValue.ToLower() == DateTimePicker.TIME_NOW.ToLower())) { newColumnDefaultValue = ffiUpdated.DefaultValue; } else { try { DateTime dat = DateTime.Parse(ffiUpdated.DefaultValue); newColumnDefaultValue = dat.ToString(); } catch { newColumnDefaultValue = DateTime.Now.ToString(); errorMessage = GetString("TemplateDesigner.ErrorDefaultValueDateTime"); } } break; case FormFieldDataTypeEnum.File: case FormFieldDataTypeEnum.GUID: try { Guid g = new Guid(ffiUpdated.DefaultValue); newColumnDefaultValue = g.ToString(); } catch { newColumnDefaultValue = Guid.Empty.ToString(); errorMessage = GetString("TemplateDesigner.ErrorDefaultValueGuid"); } break; case FormFieldDataTypeEnum.LongText: case FormFieldDataTypeEnum.Text: case FormFieldDataTypeEnum.Boolean: newColumnDefaultValue = ffiUpdated.DefaultValue; break; } } } // Set column type and size LoadColumnTypeAndSize(ffiUpdated.DataType, ffiUpdated.Size, ref newColumnType, ref newColumnSize); if (string.IsNullOrEmpty(errorMessage)) { if (!IsAlternativeForm) { switch (mMode) { case FieldEditorModeEnum.ClassFormDefinition: case FieldEditorModeEnum.BizFormDefinition: case FieldEditorModeEnum.SystemTable: case FieldEditorModeEnum.CustomTable: try { string newDBDefaultValue = null; // Check if it is not a macro if (ffiUpdated.IsMacro) { newDBDefaultValue = newColumnDefaultValue; } else { switch (ffiUpdated.DataType) { case FormFieldDataTypeEnum.Decimal: newDBDefaultValue = FormHelper.GetDoubleValueInDBCulture(newColumnDefaultValue); break; case FormFieldDataTypeEnum.DateTime: newDBDefaultValue = FormHelper.GetDateTimeValueInDBCulture(newColumnDefaultValue); break; default: newDBDefaultValue = newColumnDefaultValue; break; } } if (ffiUpdated.External) { if (!ffi.External) { // Drop old column from table TableManager.DropTableColumn(tableName, ffi.Name); } } else { if (ffi.External) { // Add table column TableManager.AddTableColumn(tableName, newColumnName, newColumnType, newColumnAllowNull, newDBDefaultValue); } else { // Change table column TableManager.AlterTableColumn(tableName, oldColumnName, newColumnName, newColumnType, newColumnAllowNull, newDBDefaultValue); if (OnFieldNameChanged != null) { OnFieldNameChanged(this, oldColumnName, newColumnName); } } } } catch (Exception ex) { // User friendly message for not null setting of column if (ffi.AllowEmpty && !newColumnAllowNull) { lblError.Visible = true; lblError.ResourceString = "FieldEditor.ColumnNotAcceptNull"; lblError.ToolTip = ex.Message; } else { lblError.Visible = true; lblError.Text = ex.Message; } return; } break; } } } // Some error has occurred else { lblError.Visible = true; lblError.Text = errorMessage; return; } } // End update needed } // End existing node // Insert new field if (isNewItem) { InsertFormItem(ffiUpdated); } // Update current field else { fi.UpdateFormField(ffi.Name, ffiUpdated); } } else if (SelectedItemType == FieldEditorSelectedItemEnum.Category) { // Fill FormCategoryInfo structure with original data fci = fi.GetFormCategory(SelectedItemName); // Determine whether it is a new attribute or not isNewItem = (fci == null); // Fill FormCategoryInfo structure with updated form data fciUpdated = new FormCategoryInfo(); fciUpdated.CategoryCaption = categoryEdit.Value.Replace("'", ""); // Check if the category caption is empty if (string.IsNullOrEmpty(fciUpdated.CategoryCaption)) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorCategoryNameEmpty"; return; } if (isNewItem) { // Use category caption for name attribut fciUpdated.CategoryName = fciUpdated.CategoryCaption; } else { fciUpdated.CategoryName = SelectedItemName; } if (isNewItem) { // Get form category names string[] categoryNames = fi.GetCategoryNames(); if (categoryNames != null) { // Check if the category name is unique foreach (string name in categoryNames) { // If name already exists return error if (fciUpdated.CategoryName == name) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorExistingCategoryName"; return; } } } // Insert new category InsertFormItem(fciUpdated); } else { // Update current fi.UpdateFormCategory(fci.CategoryName, fciUpdated); } } // Make changes in database if (SelectedItemType != 0) { // Get updated definition FormDefinition = fi.GetXmlDefinition(); string error = null; if (!IsAlternativeForm) { switch (mMode) { case FieldEditorModeEnum.WebPartProperties: if (wpi != null) { // Update xml definition wpi.WebPartProperties = FormDefinition; try { WebPartInfoProvider.SetWebPartInfo(wpi); } catch (Exception ex) { error = ex.Message; } } else { error = GetString("FieldEditor.WebpartNotFound"); } break; case FieldEditorModeEnum.ClassFormDefinition: case FieldEditorModeEnum.BizFormDefinition: case FieldEditorModeEnum.SystemTable: case FieldEditorModeEnum.CustomTable: if (dci != null) { // Update xml definition dci.ClassFormDefinition = FormDefinition; // Update xml schema dci.ClassXmlSchema = TableManager.GetXmlSchema(dci.ClassTableName); // When updating existing field if (ffi != null) { // Update ClassNodeNameSource field if (dci.ClassNodeNameSource == ffi.Name) { dci.ClassNodeNameSource = ffiUpdated.Name; } } bool fieldType = (SelectedItemType == FieldEditorSelectedItemEnum.Field); // Update changes in DB try { // Save the data class DataClassInfoProvider.SetDataClass(dci); // Generate the class code GenerateCode(); // Update inherited classes with new fields FormHelper.UpdateInheritedClasses(dci); } catch (Exception ex) { error = ex.Message; } if (fieldType) { // Generate default view if (mMode == FieldEditorModeEnum.BizFormDefinition) { SqlGenerator.GenerateDefaultView(dci, CMSContext.CurrentSiteName); } else { SqlGenerator.GenerateDefaultView(dci, null); } // Regenerate queries SqlGenerator.GenerateDefaultQueries(dci, true, true); } // Updates custom views if ((mMode == FieldEditorModeEnum.SystemTable) || (mMode == FieldEditorModeEnum.ClassFormDefinition)) { try { TableManager.RefreshCustomViews(dci.ClassTableName); string lowClassName = dci.ClassName.ToLower(); if (lowClassName == "cms.document" || lowClassName == "cms.tree") { TableManager.RefreshDocumentViews(); } } catch (Exception ex) { error = ResHelper.GetString("fieldeditor.refreshingviewsfailed"); EventLogProvider ev = new EventLogProvider(); ev.LogEvent("Field Editor", "EXCEPTION", ex); } } } else { error = GetString("FieldEditor.ClassNotFound"); } break; } } if (!string.IsNullOrEmpty(error)) { lblError.Visible = true; lblError.Text = "[FieldEditor.SaveSelectedField()]: " + error; } else { IsNewItemEdited = false; if (SelectedItemType == FieldEditorSelectedItemEnum.Category) { Reload(categPreffix + fciUpdated.CategoryName); } else if (SelectedItemType == FieldEditorSelectedItemEnum.Field) { Reload(fieldPreffix + ffiUpdated.Name); } lblError.Visible = false; lblInfo.Visible = true; lblInfo.ResourceString = "general.changessaved"; } } // All done and new item, fire OnFieldCreated event if (isNewItem && (ffiUpdated != null)) { RaiseOnFieldCreated(ffiUpdated); } }
public static void Update60() { EventLogProvider evp = new EventLogProvider(); evp.LogEvent("I", DateTime.Now, "Upgrade to 6.0", "Upgrade - Start"); DataClassInfo dci = null; #region "CMS.UserSettings" try { dci = DataClassInfoProvider.GetDataClass("cms.usersettings"); if (dci != null) { FormInfo fi = new FormInfo(dci.ClassFormDefinition); if (fi != null) { FormFieldInfo ffi = new FormFieldInfo(); ffi.Name = "UserAuthenticationGUID"; ffi.DataType = FormFieldDataTypeEnum.GUID; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "UserBounces"; ffi.DataType = FormFieldDataTypeEnum.Integer; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.TextBoxControl; ffi.Visible = false; ffi.Caption = "UserBounces"; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "UserLinkedInID"; ffi.DataType = FormFieldDataTypeEnum.Text; ffi.Size = 100; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "UserLogActivities"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "UserPasswordRequestHash"; ffi.DataType = FormFieldDataTypeEnum.Text; ffi.Size = 100; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); dci.ClassFormDefinition = fi.GetXmlDefinition(); TableManager tm = new TableManager(dci.ClassConnectionString); dci.ClassXmlSchema = tm.GetXmlSchema("CMS_UserSettings"); DataClassInfoProvider.SetDataClass(dci); // Generate queries SqlGenerator.GenerateDefaultQueries(dci, true, false); tm.RefreshCustomViews("CMS_UserSettings"); } } } catch (Exception ex) { evp.LogEvent("CMS.UserSettings - Upgrade", "Upgrade", ex); } #endregion #region "Ecommerce - Customer" try { dci = DataClassInfoProvider.GetDataClass("ecommerce.customer"); if (dci != null) { FormInfo fi = new FormInfo(dci.ClassFormDefinition); if (fi != null) { FormFieldInfo ffi = new FormFieldInfo(); ffi.Name = "CustomerSiteID"; ffi.DataType = FormFieldDataTypeEnum.Integer; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.TextBoxControl; ffi.Visible = false; fi.AddFormField(ffi); TableManager tm = new TableManager(dci.ClassConnectionString); dci.ClassFormDefinition = fi.GetXmlDefinition(); dci.ClassXmlSchema = tm.GetXmlSchema("COM_Customer"); DataClassInfoProvider.SetDataClass(dci); // Generate queries SqlGenerator.GenerateDefaultQueries(dci, true, false); tm.RefreshCustomViews("COM_Customer"); } } } catch (Exception ex) { evp.LogEvent("Ecommerce.Customer - Upgrade", "Upgrade", ex); } #endregion #region "Ecommerce - Order" try { dci = DataClassInfoProvider.GetDataClass("ecommerce.order"); if (dci != null) { FormInfo fi = new FormInfo(dci.ClassFormDefinition); if (fi != null) { FormFieldInfo ffi = new FormFieldInfo(); ffi.Name = "OrderCulture"; ffi.DataType = FormFieldDataTypeEnum.Text; ffi.Size = 10; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderIsPaid"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderTotalPriceInMainCurrency"; ffi.DataType = FormFieldDataTypeEnum.Decimal; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = fi.GetFormField("OrderStatusID"); if (ffi != null) { ffi.AllowEmpty = true; fi.UpdateFormField("OrderStatusID", ffi); } ffi = fi.GetFormField("OrderShippingAddressID"); if (ffi != null) { ffi.AllowEmpty = true; fi.UpdateFormField("OrderShippingAddressID", ffi); } dci.ClassFormDefinition = fi.GetXmlDefinition(); TableManager tm = new TableManager(dci.ClassConnectionString); dci.ClassXmlSchema = tm.GetXmlSchema("COM_Order"); DataClassInfoProvider.SetDataClass(dci); // Generate queries SqlGenerator.GenerateDefaultQueries(dci, true, false); tm.RefreshCustomViews("COM_Order"); } } } catch (Exception ex) { evp.LogEvent("Ecommerce.Order - Upgrade", "Upgrade", ex); } #endregion #region "Ecommerce - OrderItem" try { dci = DataClassInfoProvider.GetDataClass("ecommerce.orderitem"); if (dci != null) { FormInfo fi = new FormInfo(dci.ClassFormDefinition); if (fi != null) { FormFieldInfo ffi = new FormFieldInfo(); ffi.Name = "OrderItemBundleGUID"; ffi.DataType = FormFieldDataTypeEnum.GUID; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderItemIsPrivate"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderItemPrice"; ffi.DataType = FormFieldDataTypeEnum.Decimal; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderItemSendNotification"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderItemSKU"; ffi.DataType = FormFieldDataTypeEnum.LongText; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderItemText"; ffi.DataType = FormFieldDataTypeEnum.LongText; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderItemTotalPriceInMainCurrency"; ffi.DataType = FormFieldDataTypeEnum.Decimal; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "OrderItemValidTo"; ffi.DataType = FormFieldDataTypeEnum.DateTime; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); dci.ClassFormDefinition = fi.GetXmlDefinition(); TableManager tm = new TableManager(dci.ClassConnectionString); dci.ClassXmlSchema = tm.GetXmlSchema("COM_OrderItem"); DataClassInfoProvider.SetDataClass(dci); // Generate queries SqlGenerator.GenerateDefaultQueries(dci, true, false); tm.RefreshCustomViews("COM_OrderItem"); } } } catch (Exception ex) { evp.LogEvent("Ecommerce.OrderItem - Upgrade", "Upgrade", ex); } #endregion #region "Ecommerce - Shopping cart item" try { dci = DataClassInfoProvider.GetDataClass("ecommerce.shoppingcartitem"); if (dci != null) { FormInfo fi = new FormInfo(dci.ClassFormDefinition); if (fi != null) { FormFieldInfo ffi = new FormFieldInfo(); ffi.Name = "CartItemBundleGUID"; ffi.DataType = FormFieldDataTypeEnum.GUID; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "CartItemIsPrivate"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "CartItemPrice"; ffi.DataType = FormFieldDataTypeEnum.Decimal; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "CartItemText"; ffi.DataType = FormFieldDataTypeEnum.LongText; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "CartItemValidTo"; ffi.DataType = FormFieldDataTypeEnum.DateTime; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = fi.GetFormField("CartItemGuid"); if (ffi != null) { ffi.AllowEmpty = true; fi.UpdateFormField("CartItemGuid", ffi); } dci.ClassFormDefinition = fi.GetXmlDefinition(); TableManager tm = new TableManager(dci.ClassConnectionString); dci.ClassXmlSchema = tm.GetXmlSchema("COM_ShoppingCartSKU"); DataClassInfoProvider.SetDataClass(dci); // Generate queries SqlGenerator.GenerateDefaultQueries(dci, true, false); tm.RefreshCustomViews("COM_ShoppingCartSKU"); } } } catch (Exception ex) { evp.LogEvent("Ecommerce.ShoppingCartItem - Upgrade", "Upgrade", ex); } #endregion #region "Ecommerce - SKU" try { dci = DataClassInfoProvider.GetDataClass("ecommerce.sku"); if (dci != null) { FormInfo fi = new FormInfo(dci.ClassFormDefinition); if (fi != null) { FormFieldInfo ffi = new FormFieldInfo(); ffi.Name = "SKUBundleInventoryType"; ffi.DataType = FormFieldDataTypeEnum.Text; ffi.Size = 50; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUConversionName"; ffi.DataType = FormFieldDataTypeEnum.Text; ffi.Size = 100; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUConversionValue"; ffi.DataType = FormFieldDataTypeEnum.Text; ffi.Size = 200; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUMaxDownloads"; ffi.DataType = FormFieldDataTypeEnum.Integer; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUMaxItemsInOrder"; ffi.DataType = FormFieldDataTypeEnum.Integer; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUMaxPrice"; ffi.DataType = FormFieldDataTypeEnum.Decimal; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUMembershipGUID"; ffi.DataType = FormFieldDataTypeEnum.GUID; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUMinPrice"; ffi.DataType = FormFieldDataTypeEnum.Decimal; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUNeedsShipping"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUPrivateDonation"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUProductType"; ffi.DataType = FormFieldDataTypeEnum.Text; ffi.Size = 50; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUSiteID"; ffi.DataType = FormFieldDataTypeEnum.Integer; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUValidFor"; ffi.DataType = FormFieldDataTypeEnum.Integer; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUValidity"; ffi.DataType = FormFieldDataTypeEnum.Text; ffi.Size = 50; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = new FormFieldInfo(); ffi.Name = "SKUValidUntil"; ffi.DataType = FormFieldDataTypeEnum.DateTime; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); ffi = fi.GetFormField("SKUDepartmentID"); if (ffi != null) { ffi.AllowEmpty = true; fi.UpdateFormField("SKUDepartmentID", ffi); } dci.ClassFormDefinition = fi.GetXmlDefinition(); TableManager tm = new TableManager(dci.ClassConnectionString); dci.ClassXmlSchema = tm.GetXmlSchema("COM_SKU"); DataClassInfoProvider.SetDataClass(dci); // Generate queries SqlGenerator.GenerateDefaultQueries(dci, true, false); tm.RefreshCustomViews("COM_SKU"); } } } catch (Exception ex) { evp.LogEvent("Ecommerce.SKU - Upgrade", "Upgrade", ex); } #endregion #region "Community - Group" try { dci = DataClassInfoProvider.GetDataClass("Community.Group"); if (dci != null) { FormInfo fi = new FormInfo(dci.ClassFormDefinition); if (fi != null) { FormFieldInfo ffi = new FormFieldInfo(); ffi.Name = "GroupLogActivity"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.CheckBoxControl; ffi.Visible = true; ffi.DefaultValue = "true"; ffi.Caption = "GroupLogActivity"; fi.AddFormField(ffi); dci.ClassFormDefinition = fi.GetXmlDefinition(); TableManager tm = new TableManager(dci.ClassConnectionString); dci.ClassXmlSchema = tm.GetXmlSchema("Community_Group"); DataClassInfoProvider.SetDataClass(dci); // Generate queries SqlGenerator.GenerateDefaultQueries(dci, true, false); tm.RefreshCustomViews("Community_Group"); } } } catch (Exception ex) { evp.LogEvent("Community.Group - Upgrade", "Upgrade", ex); } #endregion #region "Newsletter - Subscriber" try { dci = DataClassInfoProvider.GetDataClass("newsletter.subscriber"); if (dci != null) { FormInfo fi = new FormInfo(dci.ClassFormDefinition); if (fi != null) { FormFieldInfo ffi = new FormFieldInfo(); ffi.Name = "SubscriberBounces"; ffi.DataType = FormFieldDataTypeEnum.Boolean; ffi.AllowEmpty = true; ffi.PublicField = false; ffi.System = true; ffi.FieldType = FormFieldControlTypeEnum.LabelControl; ffi.Visible = false; fi.AddFormField(ffi); dci.ClassFormDefinition = fi.GetXmlDefinition(); TableManager tm = new TableManager(dci.ClassConnectionString); dci.ClassXmlSchema = tm.GetXmlSchema("Newsletter_Subscriber"); DataClassInfoProvider.SetDataClass(dci); // Generate queries SqlGenerator.GenerateDefaultQueries(dci, true, false); tm.RefreshCustomViews("Newsletter_Subscriber"); } } } catch (Exception ex) { evp.LogEvent("Newsletter.Subscriber - Upgrade", "Upgrade", ex); } #endregion #region "CMS.Document" try { dci = DataClassInfoProvider.GetDataClass("cms.document"); if (dci != null) { SearchSettings ss = dci.ClassSearchSettingsInfos; SearchSettingsInfo ssi = ss.GetSettingsInfo("42f446ee-9818-4596-8124-54a38f64aa05"); if (ssi != null) { ssi.Searchable = true; ss.SetSettingsInfo(ssi); } DataClassInfoProvider.SetDataClass(dci); } } catch (Exception ex) { evp.LogEvent("CMS.Document - Upgrade", "Upgrade", ex); } #endregion // Set the path to the upgrade package mUpgradePackagePath = HttpContext.Current.Server.MapPath("~/CMSSiteUtils/Import/upgrade_55R2_60.zip"); mWebsitePath = HttpContext.Current.Server.MapPath("~/"); TableManager dtm = new TableManager(null); // Update all views dtm.RefreshDocumentViews(); // Set data version ObjectHelper.SetSettingsKeyValue("CMSDataVersion", "6.0"); // Clear hashtables CMSObjectHelper.ClearHashtables(); // Clear the cache CacheHelper.ClearCache(null, true); // Drop the routes CMSMvcHandler.DropAllRoutes(); // Init the Mimetype helper (required for the Import) MimeTypeHelper.LoadMimeTypes(); CMSThread thread = new CMSThread(Upgrade60Import); thread.Start(); }
/// <summary> /// OnSaveData event handler. Sets security properties. /// </summary> protected void DocumentManager_OnSaveData(object sender, DocumentManagerEventArgs e) { TreeNode node = e.Node; if (node != null) { string message = null; bool clearCache = false; // Authentication if (!pnlAuth.IsHidden) { int isSecuredNode = node.IsSecuredNode; if (radYes.Checked) { isSecuredNode = 1; } else if (radNo.Checked) { isSecuredNode = 0; } else if (radParent.Checked) { isSecuredNode = -1; } // Set secured areas settings if (isSecuredNode != node.IsSecuredNode) { node.IsSecuredNode = isSecuredNode; clearCache = true; message += ResHelper.GetAPIString("security.documentaccessauthchanged", "Page authentication settings have been modified."); } } // SSL if (!pnlSSL.IsHidden) { int requiresSSL = node.RequiresSSL; if (radYesSSL.Checked) { requiresSSL = 1; } else if (radNoSSL.Checked) { requiresSSL = 0; } else if (radParentSSL.Checked) { requiresSSL = -1; } else if (radNeverSSL.Checked) { requiresSSL = 2; } // Set SSL settings if (requiresSSL != node.RequiresSSL) { node.RequiresSSL = requiresSSL; clearCache = true; if (message != null) { message += "<br />"; } message += ResHelper.GetAPIString("security.documentaccesssslchanged", "Page SSL settings have been modified."); } } // Insert information about this event to event log. if (DocumentManager.Tree.LogEvents && (message != null)) { EventLogProvider.LogEvent(EventType.INFORMATION, "Content", "DOCACCESSMODIFIED", message, eventUrl, currentUser.UserID, currentUser.UserName, node.NodeID, DocumentName, ipAddress, node.NodeSiteID); } // Clear cache if security settings changed if (clearCache) { CacheHelper.ClearPageInfoCache(node.NodeSiteName); CacheHelper.ClearFileNodeCache(node.NodeSiteName); } // Clear ACL settings securityElem.InvalidateAcls(); } }
/// <summary> /// Initializes common properties used for processing image. /// </summary> void baseImageEditor_InitializeProperties() { // Process media file if (baseImageEditor.ImageType == ImageHelper.ImageTypeEnum.MediaFile) { // Get mediafile mfi = MediaFileInfoProvider.GetMediaFileInfo(mediafileGuid, this.CurrentSiteName); // If file is not null if (mfi != null) { MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(mfi.FileLibraryID); if ((mli != null) && (MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "filemodify"))) { // Load media file thumbnail if (isPreview) { PreviewPath = MediaFileInfoProvider.GetPreviewFilePath(mfi); if (PreviewPath != null) { OldPreviewExt = Path.GetExtension(PreviewPath); try { // Get file contents from file system previewFile = File.ReadAllBytes(PreviewPath); } catch (Exception ex) { EventLogProvider ev = new EventLogProvider(); ev.LogEvent("ImageEditor", "GetPreviewFile", ex); } if (previewFile != null) { baseImageEditor.ImgHelper = new ImageHelper(previewFile); } else { baseImageEditor.LoadingFailed = true; baseImageEditor.LblLoadFailed.ResourceString = "img.errors.loading"; } } else { baseImageEditor.LoadingFailed = true; baseImageEditor.LblLoadFailed.ResourceString = "img.errors.loading"; } } // Load media file else { mfi.FileBinary = MediaFileInfoProvider.GetFile(mfi, mli.LibraryFolder, this.CurrentSiteName); // Ensure metafile binary data if (mfi.FileBinary != null) { baseImageEditor.ImgHelper = new ImageHelper(mfi.FileBinary); } else { baseImageEditor.LoadingFailed = true; baseImageEditor.LblLoadFailed.ResourceString = "img.errors.loading"; } } } else { baseImageEditor.LoadingFailed = true; baseImageEditor.LblLoadFailed.ResourceString = "img.errors.filemodify"; } } else { baseImageEditor.LoadingFailed = true; baseImageEditor.LblLoadFailed.ResourceString = "img.errors.loading"; } } // Check that image is in supported formats if ((!baseImageEditor.LoadingFailed) && (baseImageEditor.ImgHelper.ImageFormatToString() == null)) { baseImageEditor.LoadingFailed = true; baseImageEditor.LblLoadFailed.ResourceString = "img.errors.format"; } }
/// <summary> /// Resets permission inheritance of node and its children. /// </summary> /// <param name="siteName">Name of site</param> /// <param name="nodeAliasPath">Alias path</param> /// <param name="recursive">Indicates whether to recursively reset all nodes below the current node</param> /// <param name="user">Current user</param> /// <param name="tr">Tree provider</param> /// <returns>Whether TRUE if no permission conflict has occurred</returns> private bool ResetNodePermission(string siteName, string nodeAliasPath, bool recursive, UserInfo user, TreeProvider tr) { // Check permissions bool permissionsResult = false; try { if (tr == null) { tr = new TreeProvider(user); } // Get node by alias path TreeNode treeNode = tr.SelectSingleNode(siteName, nodeAliasPath, null, true, null, false); permissionsResult = CanModifyPermission(!recursive, treeNode, user); if (treeNode != null) { // If user has permissions if (permissionsResult) { // Break inheritance of a node if (!AclInfoProvider.DoesNodeInheritPermissions(treeNode)) { // Restore inheritance of a node AclInfoProvider.RestoreInheritance(treeNode); // Log current encoded alias path AddLog(HTMLHelper.HTMLEncode(nodeAliasPath)); // Log staging task and flush cache DocumentSynchronizationHelper.LogDocumentChange(treeNode, TaskTypeEnum.RestoreACLInheritance, treeNode.TreeProvider, SynchronizationInfoProvider.ENABLED_SERVERS, null, treeNode.TreeProvider.AllowAsyncActions); Node.ClearCache(); // Insert information about this event to event log. if (DocumentManager.Tree.LogEvents) { if (recursive) { LogContext.LogEventToCurrent(EventType.INFORMATION, "Content", "DOCPERMISSIONSMODIFIED", string.Format(ResHelper.GetAPIString("security.documentpermissionsrestoredfordoc", "Permissions of the page '{0}' have been restored to the parent page permissions."), nodeAliasPath), null, user.UserID, user.UserName, treeNode.NodeID, treeNode.GetDocumentName(), ipAddress, Node.NodeSiteID, null, null, null, DateTime.Now); } else { EventLogProvider.LogEvent(EventType.INFORMATION, "Content", "DOCPERMISSIONSMODIFIED", ResHelper.GetAPIString("security.documentpermissionsrestored", "Permissions have been restored to the parent page permissions."), eventUrl, user.UserID, user.UserName, treeNode.NodeID, treeNode.GetDocumentName(), ipAddress, Node.NodeSiteID); } } } else { AddLog(string.Format(GetString("cmsdesk.skippingrestoring"), HTMLHelper.HTMLEncode(nodeAliasPath))); } } // Recursively reset node inheritance if (recursive) { // Get child nodes of current node DataSet ds = DocumentManager.Tree.SelectNodes(siteName, treeNode.NodeAliasPath.TrimEnd('/') + "/%", TreeProvider.ALL_CULTURES, true, null, null, null, 1, false, -1, DocumentColumnLists.SELECTNODES_REQUIRED_COLUMNS + ",NodeAliasPath"); if (!DataHelper.DataSourceIsEmpty(ds)) { foreach (DataRow dr in ds.Tables[0].Rows) { string childNodeAliasPath = ValidationHelper.GetString(dr["NodeAliasPath"], string.Empty); if (!string.IsNullOrEmpty(childNodeAliasPath)) { bool tempPermissionsResult = ResetNodePermission(siteName, childNodeAliasPath, true, user, tr); permissionsResult = tempPermissionsResult && permissionsResult; } } } } } } catch (ThreadAbortException ex) { if (CMSThread.Stopped(ex)) { // When canceled CurrentInfo = GetString("cmsdesk.restoringcanceled"); AddLog(CurrentInfo); } else { // Log error CurrentError = GetString("cmsdesk.restoringfailed") + ": " + ex.Message; AddLog(CurrentError); } } catch (Exception ex) { // Log error CurrentError = GetString("cmsdesk.restoringfailed") + ": " + ex.Message; AddLog(CurrentError); } return(permissionsResult); }
/// <summary> /// Render override. /// </summary> protected override void Render(HtmlTextWriter writer) { // if everything ok, email should be send if (mSendEmail) { StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); Html32TextWriter mwriter = new Html32TextWriter(sw); repItems.RenderControl(mwriter); repItems.Visible = false; // Prepare the macro resolver ContextResolver resolver = ContextResolver.CreateContextChild(); string[,] replacements = new string[2, 2]; // Prepare macro replacements replacements[0, 0] = "message"; replacements[0, 1] = txtMessageText.Text; replacements[1, 0] = "document"; replacements[1, 1] = URLHelper.MakeLinksAbsolute(sb.ToString()); resolver.SourceParameters = replacements; if (EmailTemplate != null) { EmailMessage message = new EmailMessage(); message.EmailFormat = EmailFormatEnum.Html; message.From = EmailFrom; message.Recipients = txtEmailTo.Text; // Get current css stylesheet string styleSheet = URLHelper.MakeLinksAbsolute(GetCssFileLink()); // resolve EmailSubject here message.Subject = resolver.ResolveMacros(EmailSubject); // resolve EmailTemplate, wrap to HTML code and add the CSS files message.Body = "<html><head>" + styleSheet + "</head><body class=\"EmailBody\">" + resolver.ResolveMacros(EmailTemplate) + "</body></html>"; // check recipients if ((message.Recipients != null) && (message.Recipients.Trim() != "")) { try { EmailSender.SendEmail(CMSContext.CurrentSiteName, message); // Display message, email was sent successfully lblInfo.Text = GetString("sendtofriend.emailsent"); txtEmailTo.Text = ""; txtMessageText.Text = ""; } catch (Exception ex) { lblError.Text = GetString("SendToFriend.SendEmailError"); try { EventLogProvider eventLog = new EventLogProvider(); eventLog.LogEvent("Send email", "SendToFriend", ex); } catch { // Unable to log the event } } } } } base.Render(writer); }
/// <summary> /// Bind tree view. /// </summary> /// <param name="dirPath">Directory path</param> /// <param name="parentNode">Parent node</param> /// <param name="isRoot">Indicates if current parentNode is root</param> private void BindTreeView(string dirPath, TreeNode parentNode, bool isRoot = false) { if (Directory.Exists(dirPath)) { string hidenFolder = "\\" + MediaLibraryHelper.GetMediaFileHiddenFolder(SiteContext.CurrentSiteName); // Get directories string[] dirs = null; try { dirs = Directory.GetDirectories(dirPath); } catch (Exception exception) { // Ignore directories that are not accessible if (!(exception is UnauthorizedAccessException || exception is IOExceptions.PathTooLongException)) { EventLogProvider.LogException("Media library", "READOBJ", exception); } } if (dirs != null) { int index = 1; foreach (string dir in dirs) { if (!dir.EndsWithCSafe(hidenFolder, true)) { int dirCount = 0; string[] directories = null; string[] files = null; string text = dir.Substring(dir.LastIndexOfCSafe('\\')).Trim('\\'); // Get the files and directories try { if (DisplayFilesCount) { files = Directory.GetFiles(dir); } directories = Directory.GetDirectories(dir); if (directories != null) { dirCount = directories.Length; } } catch (Exception exception) { // Ignore files and directories that are not accessible if (!(exception is UnauthorizedAccessException || exception is IOExceptions.PathTooLongException)) { EventLogProvider.LogException("Media library", "READOBJ", exception); } } TreeNode node; if (ShowFolder(index)) { if (DisplayFilesCount && (files != null)) { node = CreateNode("<span class=\"Name\">" + text + " (" + files.Length + ")</span>", text, parentNode, dirCount, index); } else { node = CreateNode("<span class=\"Name\">" + text + "</span>", text, parentNode, dirCount, index); } if (dirCount == 1) { node.PopulateOnDemand = !directories[0].EndsWithCSafe(hidenFolder); } else { node.PopulateOnDemand = (dirCount > 0); } // Check if there is node within the current path to be selected if (!string.IsNullOrEmpty(PathToSelect)) { EnsureNodeExpand(parentNode, node); } parentNode.ChildNodes.Add(node); } else { node = CreateNode("<span class=\"Name\">" + GetString("general.seelisting") + "</span>", "", parentNode, 0, index); parentNode.ChildNodes.Add(node); RootHasMore = (isRoot && !CloseListing); } if (ShowFolder(index)) { index++; } else { break; } } } } } }
/// <summary> /// Did you mean suggestion. /// </summary> private static string DidYouMean(string dictionaryFile, string searchQuery, IEnumerable <string> searchTerms) { if (searchTerms != null) { Spelling SpellChecker = null; WordDictionary WordDictionary = null; #region "Word dictionary" // If not in cache, create new WordDictionary = new WordDictionary(); WordDictionary.EnableUserFile = false; // Getting folder for dictionaries string folderName = HttpContext.Current.Request.MapPath("~/App_Data/Dictionaries/"); // Check if dictionary file exists string fileName = Path.Combine(folderName, dictionaryFile); if (!File.Exists(fileName)) { EventLogProvider.LogEvent(EventType.ERROR, "DidYouMean webpart", "Dictionary file not found!"); return(String.Empty); } WordDictionary.DictionaryFolder = folderName; WordDictionary.DictionaryFile = dictionaryFile; // Load and initialize the dictionary WordDictionary.Initialize(); #endregion #region "SpellCheck" // Prepare spellchecker SpellChecker = new Spelling(); SpellChecker.Dictionary = WordDictionary; SpellChecker.SuggestionMode = Spelling.SuggestionEnum.NearMiss; bool suggest = false; // Check all searched terms foreach (string term in searchTerms) { if (term.Length > 2) { SpellChecker.Suggest(term); ArrayList al = SpellChecker.Suggestions; // If there are some suggestions if ((al != null) && (al.Count > 0)) { suggest = true; // Expression to find term Regex regex = RegexHelper.GetRegex("([\\+\\-\\s\\(]|^)" + term + "([\\s\\)]|$)"); // Change term in original search query string suggestion = "$1" + startTag + al[0] + endTag + "$2"; searchQuery = regex.Replace(searchQuery, suggestion); } } } #endregion if (suggest) { return(searchQuery); } } return(String.Empty); }
/// <summary> /// When exception occurs, log it to event log. /// </summary> /// <param name="ex">Exception to log</param> private void LogExceptionToEventLog(Exception ex) { EventLogProvider.LogException("Contact management", "DELETECONTACT", ex); AddError(GetString("om.contact.deletefailed") + ": " + ex.Message); }
/// <summary> /// Delete attribute button clicked. /// </summary> protected void btnDeleteItem_Click(Object sender, System.Web.UI.ImageClickEventArgs e) { if (Mode == FieldEditorModeEnum.BizFormDefinition) { // Check 'EditForm' permission if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.form", "EditForm")) { RedirectToAccessDenied("cms.form", "EditForm"); } } // Raise on before definition update event if (OnBeforeDefinitionUpdate != null) { OnBeforeDefinitionUpdate(this, EventArgs.Empty); } FormFieldInfo ffiSelected = null; DataClassInfo dci = null; WebPartInfo wpi = null; string errorMessage = null; string newSelectedValue = null; string deletedItemPreffix = null; // Clear settings simpleMode.Settings = new Hashtable(); controlSettings.Settings = new Hashtable(); // Load current xml form definition LoadFormDefinition(); if ((!string.IsNullOrEmpty(SelectedItemName)) && (!IsNewItemEdited)) { if (SelectedItemType == FieldEditorSelectedItemEnum.Field) { ffiSelected = fi.GetFormField(SelectedItemName); deletedItemPreffix = fieldPreffix; if (ffiSelected != null) { // Do not allow deleting of the primary key except for external fields if (ffiSelected.PrimaryKey && !ffiSelected.External) { if (!this.DevelopmentMode) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorCannotDeletePK"; return; } else { // Check if at least one primary key stays if (fi.GetFields(true, true, false, true).Length < 2) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorCannotDeletePK"; return; } } } // Check if at least two fields stay in document type definition if ((this.Mode == FieldEditorModeEnum.ClassFormDefinition) && (fi.GetFields(true, true, true).Length < 3)) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorCannotDeleteAllCustomFields"; return; } // Do not allow deleting of the system field if (ffiSelected.System && !ffiSelected.External && !DevelopmentMode) { lblError.Visible = true; lblError.ResourceString = "TemplateDesigner.ErrorCannotDeleteSystemField"; return; } // Remove specifield field from xml form definition fi.RemoveFormField(SelectedItemName); // Get updated definition FormDefinition = fi.GetXmlDefinition(); switch (mMode) { case FieldEditorModeEnum.WebPartProperties: // Web part properties { wpi = WebPartInfoProvider.GetWebPartInfo(mWebPartId); if (wpi != null) { wpi.WebPartProperties = FormDefinition; try { WebPartInfoProvider.SetWebPartInfo(wpi); } catch (Exception ex) { errorMessage = ex.Message; } } else { errorMessage = GetString("FieldEditor.WebpartNotFound"); } } break; case FieldEditorModeEnum.ClassFormDefinition: case FieldEditorModeEnum.BizFormDefinition: case FieldEditorModeEnum.SystemTable: case FieldEditorModeEnum.CustomTable: { // Standard classes dci = DataClassInfoProvider.GetDataClass(mClassName); if (dci != null) { // If document type is edited AND field that should be removed is FILE if ((mMode == FieldEditorModeEnum.ClassFormDefinition) && (!string.IsNullOrEmpty(ClassName)) && (ffiSelected.DataType == FormFieldDataTypeEnum.File)) { DocumentHelper.DeleteDocumentAttachments(ClassName, ffiSelected.Name, null); } // If bizform is edited AND field that should be removed is FILE if ((mMode == FieldEditorModeEnum.BizFormDefinition) && (!string.IsNullOrEmpty(ClassName)) && (ffiSelected.FieldType == FormFieldControlTypeEnum.UploadControl)) { BizFormInfoProvider.DeleteBizFormFiles(ClassName, ffiSelected.Name, CMSContext.CurrentSiteID); } // Update xml definition dci.ClassFormDefinition = FormDefinition; try { if (!ffiSelected.External) { // Remove corresponding column from table TableManager.DropTableColumn(dci.ClassTableName, SelectedItemName); // Update xml schema dci.ClassXmlSchema = TableManager.GetXmlSchema(dci.ClassTableName); } } catch (Exception ex) { errorMessage = ex.Message; } // Deleted field is used as ClassNodeNameSource -> remove node name source if (dci.ClassNodeNameSource == SelectedItemName) { dci.ClassNodeNameSource = ""; } // Update changes in database try { using (CMSActionContext context = new CMSActionContext()) { // Do not log synchronization for BizForm if (mMode == FieldEditorModeEnum.BizFormDefinition) { context.DisableLogging(); } // Save the data class DataClassInfoProvider.SetDataClass(dci); // Update inherited classes with new fields FormHelper.UpdateInheritedClasses(dci); } } catch (Exception ex) { errorMessage = ex.Message; } // Refresh views and quries only if changes to DB were made if (!ffiSelected.External) { // Generate default view if (mMode == FieldEditorModeEnum.BizFormDefinition) { SqlGenerator.GenerateDefaultView(dci, CMSContext.CurrentSiteName); } else { SqlGenerator.GenerateDefaultView(dci, null); } // Regenerate queries SqlGenerator.GenerateDefaultQueries(dci, true, true); // Updates custom views if ((mMode == FieldEditorModeEnum.SystemTable) || (mMode == FieldEditorModeEnum.ClassFormDefinition)) { try { TableManager.RefreshCustomViews(dci.ClassTableName); string lowClassName = dci.ClassName.ToLower(); if (lowClassName == "cms.document" || lowClassName == "cms.tree") { TableManager.RefreshDocumentViews(); } } catch (Exception ex) { errorMessage = ResHelper.GetString("fieldeditor.refreshingviewsfailed"); EventLogProvider ev = new EventLogProvider(); ev.LogEvent("Field Editor", "EXCEPTION", ex); } } } // Clear hashtables ClearHashtables(); } else { errorMessage = GetString("FieldEditor.ClassNotFound"); } } break; } } } else if (SelectedItemType == FieldEditorSelectedItemEnum.Category) { deletedItemPreffix = categPreffix; // Remove specifield category from xml form definition fi.RemoveFormCategory(SelectedItemName); // Get updated form definition FormDefinition = fi.GetXmlDefinition(); switch (mMode) { case FieldEditorModeEnum.WebPartProperties: wpi = WebPartInfoProvider.GetWebPartInfo(mWebPartId); if (wpi != null) { wpi.WebPartProperties = FormDefinition; try { WebPartInfoProvider.SetWebPartInfo(wpi); } catch (Exception ex) { errorMessage = ex.Message; } } else { errorMessage = GetString("FieldEditor.WebpartNotFound"); } break; case FieldEditorModeEnum.ClassFormDefinition: case FieldEditorModeEnum.BizFormDefinition: case FieldEditorModeEnum.SystemTable: case FieldEditorModeEnum.CustomTable: dci = DataClassInfoProvider.GetDataClass(mClassName); if (dci != null) { // Update xml definition dci.ClassFormDefinition = FormDefinition; // Update changes in database try { using (CMSActionContext context = new CMSActionContext()) { // Do not log synchronization for BizForm if (mMode == FieldEditorModeEnum.BizFormDefinition) { context.DisableLogging(); } // Save the data class DataClassInfoProvider.SetDataClass(dci); // Update inherited classes with new fields FormHelper.UpdateInheritedClasses(dci); } } catch (Exception ex) { errorMessage = ex.Message; } } else { errorMessage = GetString("FieldEditor.ClassNotFound"); } break; } } if (!string.IsNullOrEmpty(errorMessage)) { lblError.Visible = true; lblError.Text = "[ FieldEditor.btnDeleteItem_Click() ]: " + errorMessage; } } else { // "delete" new item from the list IsNewItemEdited = false; } // Set new selected value ListItem deletedItem = lstAttributes.Items.FindByValue(deletedItemPreffix + SelectedItemName); int deletedItemIndex = lstAttributes.Items.IndexOf(deletedItem); if ((deletedItemIndex > 0) && (lstAttributes.Items[deletedItemIndex - 1] != null)) { newSelectedValue = lstAttributes.Items[deletedItemIndex - 1].Value; } // Reload data Reload(newSelectedValue); // Raise on after definition update event if (OnAfterDefinitionUpdate != null) { OnAfterDefinitionUpdate(this, EventArgs.Empty); } }
/// <summary> /// Gets FormEngineUserControl instance for the input SettingsKeyInfo object. /// </summary> /// <param name="key">SettingsKeyInfo</param> /// <param name="groupNo">Number representing index of the processing settings group</param> /// <param name="keyNo">Number representing index of the processing SettingsKeyInfo</param> private FormEngineUserControl GetFormEngineUserControl(SettingsKeyInfo key, int groupNo, int keyNo) { string controlNameOrPath = key.KeyEditingControlPath; if (string.IsNullOrEmpty(controlNameOrPath)) { return(null); } // Try to get form control by its name FormEngineUserControl control = null; var formUserControl = FormUserControlInfoProvider.GetFormUserControlInfo(controlNameOrPath); if (formUserControl != null) { var formProperties = formUserControl.UserControlMergedParameters; if (formUserControl.UserControlParentID > 0) { // Get parent user control var parentFormUserControl = FormUserControlInfoProvider.GetFormUserControlInfo(formUserControl.UserControlParentID); if (parentFormUserControl != null) { formUserControl = parentFormUserControl; } } // Create FormInfo and load control control = Page.LoadUserControl(FormUserControlInfoProvider.GetFormUserControlUrl(formUserControl)) as FormEngineUserControl; if (control != null) { FormInfo fi = FormHelper.GetFormControlParameters(controlNameOrPath, formProperties, false); control.LoadDefaultProperties(fi); if (!string.IsNullOrEmpty(key.KeyFormControlSettings)) { control.FieldInfo = FormHelper.GetFormControlSettingsFromXML(key.KeyFormControlSettings); control.LoadControlFromFFI(); } } } else { // Try to load the control try { control = Page.LoadUserControl(controlNameOrPath) as FormEngineUserControl; } catch (Exception ex) { EventLogProvider.LogException("Settings", "LoadControl", ex); } } if (control == null) { return(null); } control.ID = string.Format(@"key{0}{1}", groupNo, keyNo); control.IsLiveSite = false; return(control); }