protected void gridFile_OnAction(string actionName, object actionArgument)
{
switch (actionName.ToLower())
{
case "delete":
try
{
// Get meta file ID
int metaFileId = ValidationHelper.GetInteger(actionArgument, 0);
// Get meta file
MetaFileInfo mfi = MetaFileInfoProvider.GetMetaFileInfo(metaFileId);
// Delete meta file
MetaFileInfoProvider.DeleteMetaFileInfo(metaFileId);
// Execute after delete event
if (OnAfterDelete != null)
{
OnAfterDelete(this, null);
}
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
}
break;
}
}
/// <summary>
/// Deletes the file binary from the file system.
/// </summary>
/// <param name="fileId">MetaFile ID</param>
/// <param name="name">Returning the metafile name</param>
protected bool DeleteFromFileSystem(int fileId, ref string name)
{
// Delete the file in file system
MetaFileInfo mi = MetaFileInfoProvider.GetMetaFileInfo(fileId);
if (mi != null)
{
name = mi.MetaFileName;
// Ensure the binary column first (check if exists)
DataSet ds = MetaFileInfoProvider.GetMetaFiles("MetaFileID = " + fileId, null, "CASE WHEN MetaFileBinary IS NULL THEN 0 ELSE 1 END AS HasBinary", -1);
if (!DataHelper.DataSourceIsEmpty(ds))
{
bool hasBinary = ValidationHelper.GetBoolean(ds.Tables[0].Rows[0][0], false);
if (!hasBinary)
{
// Copy the binary data to database
mi.MetaFileBinary = MetaFileInfoProvider.GetFile(mi, SiteInfoProvider.GetSiteName(mi.MetaFileSiteID));
mi.Generalized.UpdateData();
}
// Delete the file from the disk
MetaFileInfoProvider.DeleteFile(SiteInfoProvider.GetSiteName(mi.MetaFileSiteID), mi.MetaFileGUID.ToString(), true, false);
return(true);
}
}
return(false);
}
private void LoadMetafile()
{
if (metafile == null)
{
metafile = MetaFileInfoProvider.GetMetaFileInfoWithoutBinary(metafileGuid, CurrentSiteName, true);
}
}
/// <summary>
/// Initializes metafile.
/// </summary>
private void InitializeMetaFile()
{
MetaFileInfo metaFileInfo;
if (InfoObject != null)
{
metaFileInfo = InfoObject as MetaFileInfo;
}
else
{
// Get metafile
metaFileInfo = MetaFileInfoProvider.GetMetaFileInfoWithoutBinary(ObjectGuid, SiteName, true);
InfoObject = metaFileInfo;
}
// If file is not null and current user is global administrator then set image
if (metaFileInfo != null)
{
// Check modify permission
if (CheckPermissions && !UserInfoProvider.IsAuthorizedPerObject(metaFileInfo.MetaFileObjectType, metaFileInfo.MetaFileObjectID, PermissionsEnum.Modify, SiteContext.CurrentSiteName, MembershipContext.AuthenticatedUser))
{
RedirectToAccessDenied(GetString("metadata.errors.filemodify"));
}
// Fire event GetObjectExtension
if (GetObjectExtension != null)
{
GetObjectExtension(metaFileInfo.MetaFileExtension);
}
}
else
{
URLHelper.Redirect(AdministrationUrlHelper.GetInformationUrl("editedobject.notexists"));
}
}
/// <summary>
/// Processes a meta file upload for a new e-product.
/// Returns the ID of the related SKU file object if it was created or updated successfully, otherwise returns 0.
/// </summary>
private int ProcessUploadForNewEproduct()
{
if (SKUID == 0)
{
// SKU does not exist
return(0);
}
// Upload the file
fileElem.ObjectID = SKUID;
fileElem.UploadFile();
MetaFileInfo metaFile = fileElem.CurrentlyHandledMetaFile;
if (metaFile == null)
{
// The file was not uploaded
return(0);
}
// Create a new SKU file
SKUFileInfo skuFile = new SKUFileInfo()
{
FileSKUID = SKUID,
FileMetaFileGUID = metaFile.MetaFileGUID,
FileName = metaFile.MetaFileName,
FilePath = MetaFileInfoProvider.GetMetaFileUrl(metaFile.MetaFileGUID, metaFile.MetaFileName),
FileType = MediaSourceEnum.MetaFile.ToString()
};
SKUFileInfoProvider.SetSKUFileInfo(skuFile);
return(skuFile.FileID);
}
protected void hdnPostback_Click(object sender, EventArgs e)
{
try
{
int fileId = ValidationHelper.GetInteger(hdnField.Value, 0);
if (fileId > 0)
{
// Get uploaded meta file
MetaFileInfo mfi = MetaFileInfoProvider.GetMetaFileInfo(fileId);
// Set currently handled meta file
CurrentlyHandledMetaFile = mfi;
// Fire after upload event
if (OnAfterUpload != null)
{
OnAfterUpload(this, EventArgs.Empty);
}
// Reload grid data
gridFiles.ReloadData();
}
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
}
}
/// <summary>
/// Processes a meta file upload for an existing e-product.
/// Returns the ID of the related SKU file object if it was created or updated successfully, otherwise returns 0.
/// </summary>
private int ProcessUploadForExistingEproduct()
{
if (SKUID == 0)
{
// SKU does not exist
return(0);
}
MetaFileInfo metaFile = fileListElem.CurrentlyHandledMetaFile;
SKUFileInfo skuFile = null;
DataSet skuFiles = SKUFileInfoProvider.GetSKUFiles().WhereEquals("FileMetaFileGUID", metaFile.MetaFileGUID);
if (DataHelper.DataSourceIsEmpty(skuFiles))
{
// Create a new SKU file
skuFile = new SKUFileInfo()
{
FileSKUID = SKUID,
FileMetaFileGUID = metaFile.MetaFileGUID
};
}
else
{
// Get an existing SKU file
skuFile = new SKUFileInfo(skuFiles.Tables[0].Rows[0]);
}
skuFile.FileName = metaFile.MetaFileName;
skuFile.FilePath = MetaFileInfoProvider.GetMetaFileUrl(metaFile.MetaFileGUID, metaFile.MetaFileName);
skuFile.FileType = MediaSourceEnum.MetaFile.ToString();
SKUFileInfoProvider.SetSKUFileInfo(skuFile);
return(skuFile.FileID);
}
/// <summary>
/// Transforms inline attachment source back to metafile attachment source.
/// </summary>
/// <param name="match">Regex match result for inline attachment source</param>
/// <returns>MetaFile attachment source</returns>
private static string TransformSrc(Match match)
{
if (match.Groups.Count > 0)
{
// Get content ID (metafile GUID without '-') and make GUID of it
string cidCode = match.Groups["cidCode"].Value;
Guid mfGuid = (cidCode.Length == 32) ? ValidationHelper.GetGuid(cidCode.Insert(20, "-").Insert(16, "-").Insert(12, "-").Insert(8, "-"), Guid.Empty) : Guid.Empty;
if (mfGuid != Guid.Empty)
{
// Get metafile by GUID
MetaFileInfo mfi = MetaFileInfoProvider.GetMetaFileInfo(mfGuid, null, false);
if (mfi != null)
{
SiteInfo site = SiteInfoProvider.GetSiteInfo((mfi.MetaFileSiteID > 0) ? mfi.MetaFileSiteID : CMSContext.CurrentSiteID);
if (site != null)
{
// return metafile source
return("src=\"" + URLHelper.GetAbsoluteUrl("~/CMSPages/GetMetaFile.aspx?fileguid=" + mfGuid, site.DomainName) + "\"");
}
}
}
}
return(match.Value);
}
/// <summary>
/// Handles the OnBeforeSave event of the Form control.
/// </summary>
private void Form_OnBeforeSave(object sender, EventArgs e)
{
if (FormObject != null)
{
switch (iconType)
{
case IconTypeEnum.Metafile:
// Remove icon css class
FormObject.SetValue(IconCssFieldName, null);
txtCssClass.Text = string.Empty;
break;
case IconTypeEnum.CssClass:
// Delete uploaded metafile
Guid metaFileguid = ValidationHelper.GetGuid(Value, Guid.Empty);
if (metaFileguid != Guid.Empty)
{
MetaFileInfo metaFile = MetaFileInfoProvider.GetMetaFileInfo(metaFileguid, null, true);
MetaFileInfoProvider.DeleteMetaFileInfo(metaFile);
}
// Delete the metafile thumbnail
Value = null;
FormObject.SetValue(Field, null);
// Update the Icon CSS class field
FormObject.SetValue(IconCssFieldName, txtCssClass.Text);
break;
}
}
}
private void BasicInit()
{
// Init actions even if control is disabled. Enabled may be set late in some cases (team development).
gridFile.OnAction += gridFile_OnAction;
gridFile.OnExternalDataBound += gridFile_OnExternalDataBound;
uploader.OnUploadFile += uploader_OnUploadFile;
uploader.OnDeleteFile += uploader_OnDeleteFile;
// Initialize UniGrid only if ObjectID is present
if (ObjectID > 0)
{
gridFile.IsLiveSite = IsLiveSite;
gridFile.WhereCondition = MetaFileInfoProvider.GetWhereCondition(ObjectID, ObjectType, Category, null);
gridFile.StopProcessing = StopProcessing;
gridFile.GridView.CssClass += " table-width-30";
pnlGrid.Visible = true;
pnlAttachmentList.CssClass = "AttachmentsList SingleAttachment";
}
else
{
pnlGrid.Visible = false;
}
}
/// <summary>
/// Handles the OnBeforeSave event of the Form control.
/// </summary>
private void Form_OnBeforeSave(object sender, EventArgs e)
{
if (FormObject != null)
{
switch (ThumbnailType)
{
case ThumbnailTypeEnum.Metafile:
// Clear the Icon CSS class field
FormObject.SetValue(IconCssFieldName, string.Empty);
fontIconSelector.Value = string.Empty;
break;
case ThumbnailTypeEnum.CssClass:
// Delete uploaded metafile
Guid metaFileguid = ValidationHelper.GetGuid(Value, Guid.Empty);
if (metaFileguid != Guid.Empty)
{
MetaFileInfo metaFile = MetaFileInfoProvider.GetMetaFileInfo(metaFileguid, FormObject.Generalized.ObjectSiteName, true);
MetaFileInfoProvider.DeleteMetaFileInfo(metaFile);
}
// Delete the metafile thumbnail
Value = null;
FormObject.SetValue(Field, null);
// Update the Icon CSS class field
FormObject.SetValue(IconCssFieldName, fontIconSelector.Value);
break;
}
}
}
/// <summary>
/// Reloads control.
/// </summary>
/// <param name="forceReload">Indicates if the control should be reloaded even if it has been already loaded</param>
public void ReloadData(bool forceReload)
{
if (!loaded || forceReload)
{
if (StopProcessing)
{
gridFiles.StopProcessing = StopProcessing;
return;
}
else
{
gridFiles.Visible = true;
}
// Set where condition
gridFiles.WhereCondition = MetaFileInfoProvider.GetWhereCondition(ObjectID, ObjectType, Category, Where);
if (forceReload)
{
// Reload grid
gridFiles.ReloadData();
}
loaded = true;
}
}
private byte[] GetFileBinary(BaseInfo image)
{
switch (image)
{
case MediaFileInfo mediaFile:
// For files with uploaded binary (new file or update)
if (mediaFile.FileBinary != null)
{
return(mediaFile.FileBinary);
}
// For existing files
var mediaLibrary = MediaLibraryInfoProvider.GetMediaLibraryInfo(mediaFile.FileLibraryID);
return(MediaFileInfoProvider.GetFile(mediaFile, mediaLibrary.LibraryFolder, SiteContext.CurrentSiteName));
case MetaFileInfo metaFile:
// For files with uploaded binary (new file or update)
if (metaFile.MetaFileBinary != null)
{
return(metaFile.MetaFileBinary);
}
// For existing files
return(MetaFileInfoProvider.GetFile(metaFile, SiteContext.CurrentSiteName));
case AttachmentInfo attachment:
return(attachment.AttachmentBinary);
case AttachmentHistoryInfo attachmentHistory:
return(attachmentHistory.AttachmentBinary);
default:
return(null);
}
}
/// <summary>
/// Ensures the info objects.
/// </summary>
private void LoadInfos()
{
switch (baseImageEditor.ImageType)
{
case ImageHelper.ImageTypeEnum.Metafile:
if (mf == null)
{
mf = MetaFileInfoProvider.GetMetaFileInfoWithoutBinary(metafileGuid, CurrentSiteName, true);
}
break;
case ImageHelper.ImageTypeEnum.PhysicalFile:
// Skip loading info for physical files
break;
default:
if (ai == null)
{
baseImageEditor.Tree = new TreeProvider(MembershipContext.AuthenticatedUser);
// If using workflow then get versioned attachment
if (VersionHistoryID != 0)
{
ai = DocumentHelper.GetAttachment(attachmentGuid, VersionHistoryID);
}
// Else get file without binary data
else
{
ai = AttachmentInfoProvider.GetAttachmentInfoWithoutBinary(attachmentGuid, CurrentSiteName);
}
}
break;
}
}
/// <summary>
/// Action button handler.
/// </summary>
protected void btnOK_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(drpAction.SelectedValue))
{
List <string> items = null;
if (drpWhat.SelectedValue == "all")
{
// Get only the appropriate set of items
string where = filterWhere;
switch (drpAction.SelectedValue)
{
case "deleteindatabase":
case "copytofilesystem":
// Only process those where binary is available in DB
where = SqlHelper.AddWhereCondition(where, "MetaFileBinary IS NOT NULL");
break;
case "copytodatabase":
// Only copy those where the binary is missing
where = SqlHelper.AddWhereCondition(where, "MetaFileBinary IS NULL");
break;
}
// Get all, build the list of items
DataSet ds = MetaFileInfoProvider.GetMetaFiles(where, null, "MetaFileID", 0);
if (!DataHelper.DataSourceIsEmpty(ds))
{
items = new List <string>();
// Process all rows
foreach (DataRow dr in ds.Tables[0].Rows)
{
int fileId = ValidationHelper.GetInteger(dr["MetaFileID"], 0);
items.Add(fileId.ToString());
}
}
}
else
{
// Take selected items
items = gridFiles.SelectedItems;
}
if ((items != null) && (items.Count > 0))
{
// Setup the async log
pnlLog.Visible = true;
pnlContent.Visible = false;
ctlAsyncLog.TitleText = drpAction.SelectedItem.Text;
CurrentError = string.Empty;
// Process the file asynchronously
var parameter = new object[] { items, drpAction.SelectedValue };
ctlAsyncLog.RunAsync(p => ProcessFiles(parameter), WindowsIdentity.GetCurrent());
}
}
}
protected void AttachmentList_OnAfterChange(object sender, EventArgs e)
{
// Get number of attachments
InfoDataSet <MetaFileInfo> ds = MetaFileInfoProvider.GetMetaFiles(ObjectId, ObjectType, ObjectCategory, null, null, "MetafileID", -1);
// Register script to update hdnCount value (it is used to update attachment count in wopener)
ScriptHelper.RegisterStartupScript(this, typeof(string), "UpdateCountHolder", "document.getElementById('" + hdnCount.ClientID + "').value=" + ds.Items.Count.ToString(), true);
}
/// <summary>
/// Removes all metafiles used in invoices.
/// </summary>
private static void RemoveInvoiceMetafiles()
{
var invoiceMetafiles = MetaFileInfoProvider.GetMetaFiles()
.WhereEquals("MetaFileGroupName", "Invoice");
foreach (var metafile in invoiceMetafiles)
{
metafile.Delete();
}
}
/// <summary>
/// Uploads file with new product uploader.
/// </summary>
public void UploadNewProductFile()
{
// Get SKU
SKUInfo skui = SKUInfoProvider.GetSKUInfo(this.SKUID);
// Get allowed extensions
string allowedExtensions = null;
if (skui != null)
{
string settingKey = (skui.IsGlobal) ? "CMSUploadExtensions" : (CMSContext.CurrentSiteName + ".CMSUploadExtensions");
allowedExtensions = SettingsKeyProvider.GetStringValue(settingKey);
}
// Get posted file
HttpPostedFile file = this.newProductFileUploader.PostedFile;
if ((file != null) && (file.ContentLength > 0) && !String.IsNullOrEmpty(allowedExtensions))
{
// Get file extension
string extension = Path.GetExtension(file.FileName);;
// If file extension is not allowed
if (!FileHelper.CheckExtension(extension, allowedExtensions))
{
// Set error message and don't upload
string error = ValidationHelper.GetString(SessionHelper.GetValue("NewProductError"), null);
error += ";" + String.Format(this.GetString("com.eproduct.attachmentinvalid"), allowedExtensions.Replace(";", ", "));
SessionHelper.SetValue("NewProductError", error);
return;
}
}
// Upload attachment
this.newProductFileUploader.ObjectID = this.SKUID;
this.newProductFileUploader.UploadFile();
// Get uploaded meta file
MetaFileInfo mfi = this.newProductFileUploader.CurrentlyHandledMetaFile;
if (mfi != null)
{
// Create new SKU file
SKUFileInfo skufi = new SKUFileInfo();
skufi.FileSKUID = this.SKUID;
skufi.FileMetaFileGUID = mfi.MetaFileGUID;
skufi.FileName = mfi.MetaFileName;
skufi.FilePath = MetaFileInfoProvider.GetMetaFileUrl(mfi.MetaFileGUID, mfi.MetaFileName);
skufi.FileType = MediaSourceEnum.MetaFile.ToString();
// Save SKU file
SKUFileInfoProvider.SetSKUFileInfo(skufi);
}
}
private void SendMail(string mail, IEnumerable <ProductBookModel> list)
{
SiteInfo currentSite = SiteContext.CurrentSite;
ContextResolver resolver = MacroContext.CurrentResolver;
string emailSubject = null;
EmailTemplateInfo template = null;
template = EmailTemplateProvider.GetEmailTemplate("SendProductLinkDownload", currentSite.SiteName);
emailSubject = EmailHelper.GetSubject(template, "Demande de contact");
//mail type
if (template != null)
{
ev.LogEvent("I", DateTime.Now, "Template!=null ", (template != null).ToString());
resolver.SourceParameters = null;
EmailMessage email = new EmailMessage();
email.EmailFormat = EmailFormatEnum.Default;
email.From =
EmailHelper.GetSender(template,
SettingsKeyInfoProvider.GetStringValue(currentSite.SiteName + ".CMSAdminEmailAddress"));
email.Recipients = mail;
StringBuilder sb = new StringBuilder();
foreach (var produit in list)
{
string str = "<br/> <b>" + produit.productname + "</b> (" + produit.fileUrl + ")";
sb = sb.AppendLine(str);
}
ev.LogEvent("I", DateTime.Now, "Template ", sb.ToString());
string templatetext =
template.TemplateText.Replace("#Product", sb.ToString());
email.Body = resolver.ResolveMacros(templatetext);
resolver.EncodeResolvedValues = false;
email.PlainTextBody = resolver.ResolveMacros(template.TemplatePlainText);
email.Subject = resolver.ResolveMacros(emailSubject);
email.CcRecipients = template.TemplateCc;
email.BccRecipients = template.TemplateBcc;
try
{
MetaFileInfoProvider.ResolveMetaFileImages(email, template.TemplateID, EmailObjectType.EMAILTEMPLATE,
MetaFileInfoProvider.OBJECT_CATEGORY_TEMPLATE);
// Send the e-mail immediately
EmailSender.SendEmail(currentSite.SiteName, email, true);
}
catch (Exception ex)
{
ev.LogEvent("E", DateTime.Now, "SendMail ", ex.Message);
}
}
}
/// <summary>
/// Initializes header action control.
/// </summary>
/// <param name="templateId">Template ID</param>
protected void InitHeaderActions(int templateId)
{
bool isAuthorized = CurrentUser.IsAuthorizedPerResource("CMS.Newsletter", "ManageTemplates") && (EditedObject != null);
// Init save button
CurrentMaster.HeaderActions.ActionsList.Add(new SaveAction
{
Enabled = isAuthorized
});
// Init spellcheck button
CurrentMaster.HeaderActions.ActionsList.Add(new HeaderAction
{
Text = GetString("spellcheck.title"),
Tooltip = GetString("spellcheck.title"),
OnClientClick = "checkSpelling(spellURL); return false;",
ButtonStyle = ButtonStyle.Default,
});
int attachCount = 0;
if (isAuthorized)
{
// Get number of attachments
InfoDataSet <MetaFileInfo> ds = MetaFileInfoProvider.GetMetaFiles(templateId, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE, null, null, "MetafileID", -1);
attachCount = ds.Items.Count;
// Register attachments count update module
ScriptHelper.RegisterModule(this, "CMS/AttachmentsCountUpdater", new { Selector = "." + mAttachmentsActionClass, Text = ResHelper.GetString("general.attachments") });
// Register dialog scripts
ScriptHelper.RegisterDialogScript(Page);
}
// Prepare metafile dialog URL
string metaFileDialogUrl = ResolveUrl(@"~/CMSModules/AdminControls/Controls/MetaFiles/MetaFileDialog.aspx");
string query = string.Format("?objectid={0}&objecttype={1}", templateId, EmailTemplateInfo.OBJECT_TYPE);
metaFileDialogUrl += string.Format("{0}&category={1}&hash={2}", query, ObjectAttachmentsCategories.TEMPLATE, QueryHelper.GetHash(query));
// Init attachment button
CurrentMaster.HeaderActions.ActionsList.Add(new HeaderAction
{
Text = GetString("general.attachments") + ((attachCount > 0) ? " (" + attachCount + ")" : string.Empty),
Tooltip = GetString("general.attachments"),
OnClientClick = string.Format(@"if (modalDialog) {{modalDialog('{0}', 'Attachments', '700', '500');}}", metaFileDialogUrl) + " return false;",
Enabled = isAuthorized,
CssClass = mAttachmentsActionClass,
ButtonStyle = ButtonStyle.Default,
});
CurrentMaster.HeaderActions.ActionPerformed += HeaderActions_ActionPerformed;
}
private int GetAttachmentsCount()
{
var metafiles = MetaFileInfoProvider.GetMetaFiles(
Issue.IssueID,
Issue.IssueIsVariant ? IssueInfo.OBJECT_TYPE_VARIANT : IssueInfo.OBJECT_TYPE,
ObjectAttachmentsCategories.ISSUE,
null, null,
"MetafileID",
-1);
return(metafiles.Items.Count);
}
/// <summary>
/// Saves the widget data and create string for inline widget.
/// </summary>
private string SaveInline()
{
string script = "var widgetObj = new Object(); \n";
if (IsInline)
{
// Validate data
if (!SaveForm(formCustom))
{
return(String.Empty);
}
DataRow dr = formCustom.DataRow;
if (wi == null)
{
return(String.Empty);
}
// Name of the widget is first argument
script += String.Format("widgetObj['name']='{0}';", HttpUtility.UrlEncode(wi.WidgetName));
if (mFields == null)
{
return(String.Empty);
}
foreach (FormFieldInfo ffi in mFields)
{
if (dr.Table.Columns.Contains(ffi.Name))
{
script += String.Format("widgetObj['{0}'] = {1}; \n", ffi.Name, ScriptHelper.GetString(HttpUtility.UrlEncode(dr[ffi.Name].ToString().Replace("%", "%25"))));
}
}
// Add image GUID
DataSet ds = MetaFileInfoProvider.GetMetaFiles("MetaFileObjectID = " + wi.WidgetID + " AND MetaFileObjectType = 'cms.widget'", String.Empty, "MetafileGuid", 0);
if (!SqlHelperClass.DataSourceIsEmpty(ds))
{
Guid guid = ValidationHelper.GetGuid(ds.Tables[0].Rows[0]["MetafileGuid"], Guid.Empty);
script += "widgetObj['image_guid'] = '" + guid.ToString() + "'; \n";
}
// Add display name
script += "widgetObj['widget_displayname'] = " + ScriptHelper.GetString(HttpUtility.UrlEncode(wi.WidgetDisplayName.Replace("%", "%25"))) + "; \n";
// Create javascript for save
script += "widgetObj['cms_type'] = 'widget';\n InsertSelectedItem(widgetObj);\n";
// Add to recently used widgtets collection
CMSContext.CurrentUser.UserSettings.UpdateRecentlyUsedWidget(wi.WidgetName);
return(script);
}
return(string.Empty);
}
/// <summary>
/// Validates form data and returns TRUE if succeeded, otherwise returns FALSE.
/// </summary>
public bool ValidateData()
{
if (plcSKUControls.Visible)
{
string error = "";
if (!SKUInfoProvider.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Ecommerce, VersionActionEnum.Insert))
{
error = GetString("ecommerceproduct.versioncheck");
}
// If global meta files should be stored in filesystem
if ((error == "") && ucMetaFile.Visible && (ucMetaFile.PostedFile != null) && MetaFileInfoProvider.StoreFilesInFileSystem(null))
{
// Get product image path
string path = MetaFileInfoProvider.GetFilesFolderPath(null);
// Check permission for image folder
if (!DirectoryHelper.CheckPermissions(path))
{
error = String.Format(GetString("com.newproduct.accessdeniedtopath"), path);
}
}
// Validate SKU name
if ((error == "") && (txtSKUName.Visible) && (txtSKUName.Text.Trim() == ""))
{
// SKU name not entered
error = GetString("com.newproduct.skunameempty");
}
if (error == "")
{
// Validate SKU price
if (txtSKUPrice.Visible)
{
error = txtSKUPrice.ValidatePrice(false);
}
}
// Show error message
if (error != "")
{
lblError.Visible = true;
lblError.Text = error;
return(false);
}
}
return(true);
}
/// <summary>
/// Initializes header actions.
/// </summary>
protected void InitHeaderActions()
{
menu.ActionsList.Clear();
// Add save action
save = new SaveAction(Page);
menu.ActionsList.Add(save);
bool isAuthorized = CurrentUser.IsAuthorizedPerResource("cms.form", "EditForm") && ((formId > 0) && (EditedObject != null));
int attachCount = 0;
if (isAuthorized)
{
// Get number of attachments
InfoDataSet <MetaFileInfo> ds = MetaFileInfoProvider.GetMetaFiles(formId, FormObjectType.BIZFORM, MetaFileInfoProvider.OBJECT_CATEGORY_FORM_LAYOUT, null, null, "MetafileID", -1);
attachCount = ds.Items.Count;
string script = @"
function UpdateAttachmentCount(count) {
var counter = document.getElementById('attachmentCount');
if (counter != null) {
if (count > 0) { counter.innerHTML = ' (' + count + ')'; }
else { counter.innerHTML = ''; }
}
}";
ScriptHelper.RegisterClientScriptBlock(this, typeof(string), "UpdateAttachmentScript_" + this.ClientID, script, true);
// Register dialog scripts
ScriptHelper.RegisterDialogScript(Page);
}
// Prepare metafile dialog URL
string metaFileDialogUrl = ResolveUrl(@"~/CMSModules/AdminControls/Controls/MetaFiles/MetaFileDialog.aspx");
string query = string.Format("?objectid={0}&objecttype={1}", formId, FormObjectType.BIZFORM);
metaFileDialogUrl += string.Format("{0}&category={1}&hash={2}", query, MetaFileInfoProvider.OBJECT_CATEGORY_FORM_LAYOUT, QueryHelper.GetHash(query));
// Init attachment button
attachments = new HeaderAction()
{
ControlType = HeaderActionTypeEnum.LinkButton,
Text = GetString("general.attachments") + string.Format("<span id='attachmentCount'>{0}</span>", (attachCount > 0) ? " (" + attachCount.ToString() + ")" : string.Empty),
Tooltip = GetString("general.attachments"),
OnClientClick = string.Format(@"if (modalDialog) {{modalDialog('{0}', 'Attachments', '700', '500');}}", metaFileDialogUrl) + " return false;",
ImageUrl = isAuthorized ? GetImageUrl("Objects/CMS_MetaFile/attachment.png") : GetImageUrl("Objects/CMS_MetaFile/attachment_disabled.png"),
Enabled = isAuthorized
};
menu.ActionsList.Add(attachments);
}
/// <summary>
/// Creates and sends unsubscription e-mail.
/// </summary>
/// <param name="subscriber">Subscriber object</param>
/// <param name="news">Newsletter object</param>
/// <param name="subscription">Subscription object</param>
/// <param name="siteName">Site name</param>
protected void SendUnsubscriptionRequest(SubscriberInfo subscriber, NewsletterInfo news, SubscriberNewsletterInfo subscription, string siteName)
{
// Get global e-mail template with unsubscription request
EmailTemplateInfo et = EmailTemplateProvider.GetEmailTemplate("newsletter.unsubscriptionrequest", siteName);
if (et != null)
{
// Get subscriber member
SortedDictionary <int, SubscriberInfo> subscribers = SubscriberInfoProvider.GetSubscribers(subscriber, 1, 0);
foreach (KeyValuePair <int, SubscriberInfo> item in subscribers)
{
// Get 1st subscriber's member
SubscriberInfo sb = item.Value;
string body = et.TemplateText;
string plainBody = et.TemplatePlainText;
// Resolve newsletter macros (first name, last name etc.)
IssueHelper ih = new IssueHelper();
if (ih.LoadDynamicFields(sb, news, subscription, null, false, siteName, null, null, null))
{
body = ih.ResolveDynamicFieldMacros(body);
plainBody = ih.ResolveDynamicFieldMacros(plainBody);
}
// Create e-mail
EmailMessage msg = new EmailMessage();
msg.EmailFormat = EmailFormatEnum.Default;
msg.From = EmailHelper.GetSender(et, news.NewsletterSenderEmail);
msg.Recipients = sb.SubscriberEmail;
msg.BccRecipients = et.TemplateBcc;
msg.CcRecipients = et.TemplateCc;
msg.Subject = ResHelper.LocalizeString(et.TemplateSubject);
msg.Body = URLHelper.MakeLinksAbsolute(body);
msg.PlainTextBody = URLHelper.MakeLinksAbsolute(plainBody);
// Add attachments and send e-mail
MetaFileInfoProvider.ResolveMetaFileImages(msg, et.TemplateID, EmailObjectType.EMAILTEMPLATE, MetaFileInfoProvider.OBJECT_CATEGORY_TEMPLATE);
EmailSender.SendEmail(siteName, msg);
}
}
else
{
// Log missing template
EventLogProvider ev = new EventLogProvider();
ev.LogEvent(EventLogProvider.EVENT_TYPE_ERROR, DateTime.Now, "UnsubscriptionRequest", "Unsubscription request e-mail template is missing.");
}
}
/// <summary>
/// Updates metafile image path.
/// </summary>
private void UpdateImagePath(MediaLibraryInfo mli)
{
// Update image path according to its meta file
DataSet ds = MetaFileInfoProvider.GetMetaFiles(ucMetaFile.ObjectID, mli.TypeInfo.ObjectType);
if (!DataHelper.DataSourceIsEmpty(ds))
{
MetaFileInfo metaFile = new MetaFileInfo(ds.Tables[0].Rows[0]);
mli.LibraryTeaserPath = MetaFileInfoProvider.GetMetaFileUrl(metaFile.MetaFileGUID, metaFile.MetaFileName);
}
else
{
mli.LibraryTeaserPath = "";
}
}
/// <summary>
/// Uploads file.
/// </summary>
public void UploadFile()
{
if ((uploader.PostedFile != null) && (uploader.PostedFile.ContentLength > 0) && (ObjectID > 0))
{
try
{
MetaFileInfo existing = null;
// Check if uploaded file already exists and delete it
DataSet ds = MetaFileInfoProvider.GetMetaFiles(ObjectID, ObjectType, Category, null, null);
if (!DataHelper.DataSourceIsEmpty(ds))
{
// Get existing record ID and delete it
existing = new MetaFileInfo(ds.Tables[0].Rows[0]);
MetaFileInfoProvider.DeleteMetaFileInfo(existing);
}
// Create new meta file
MetaFileInfo mfi = new MetaFileInfo(uploader.PostedFile, ObjectID, ObjectType, Category);
if (existing != null)
{
// Preserve GUID
mfi.MetaFileGUID = existing.MetaFileGUID;
mfi.MetaFileTitle = existing.MetaFileTitle;
mfi.MetaFileDescription = existing.MetaFileDescription;
}
mfi.MetaFileSiteID = SiteID;
// Save to the database
MetaFileInfoProvider.SetMetaFileInfo(mfi);
// Set currently handled meta file
this.CurrentlyHandledMetaFile = mfi;
SetupControls();
}
catch (Exception ex)
{
lblErrorUploader.Visible = true;
lblErrorUploader.Text = ex.Message;
ViewState["SavingFailed"] = true;
SetupControls();
}
// File was uploaded, do not delete in one postback
mAlreadyUploadedDontDelete = true;
}
}
/// <summary>
/// Gets metafile preview.
/// </summary>
/// <param name="objTemplateId">Template ID</param>
protected string GetPreviewImage(object objTemplateId)
{
int templateId = ValidationHelper.GetInteger(objTemplateId, 0);
DataSet dsPreview = MetaFileInfoProvider.GetMetaFiles(templateId, WebTemplateInfo.OBJECT_TYPE);
if (!DataHelper.DataSourceIsEmpty(dsPreview))
{
string guid = ValidationHelper.GetString(dsPreview.Tables[0].Rows[0]["MetaFileGUID"], "");
return(ResolveUrl("~/CMSPages/GetMetaFile.aspx?fileguid=" + guid));
}
else
{
return(GetImageUrl("Others/Install/no_image.png"));
}
}
private void layoutElem_OnAfterSave(object sender, EventArgs e)
{
// Delete all attachments if layout was deleted
if (FormInfo != null)
{
var dci = DataClassInfoProvider.GetDataClassInfo(FormInfo.FormClassID);
if ((dci != null) && string.IsNullOrEmpty(dci.ClassFormLayout))
{
// Delete all attachments
MetaFileInfoProvider.DeleteFiles(FormInfo.FormID, BizFormInfo.OBJECT_TYPE, ObjectAttachmentsCategories.LAYOUT);
}
}
// Log synchronization
SynchronizationHelper.LogObjectChange(FormInfo, TaskTypeEnum.UpdateObject);
}
/// <summary>
/// BtnUpload click event handler.
/// </summary>
protected void btnUpload_Click(object sender, EventArgs e)
{
if (!AllowModify || (uploader.PostedFile == null) || (uploader.PostedFile.FileName.Trim() == ""))
{
return;
}
try
{
// Fire before upload event
CancelEventArgs beforeUploadArgs = new CancelEventArgs();
if (OnBeforeUpload != null)
{
OnBeforeUpload(this, beforeUploadArgs);
}
// If upload was not cancelled
if (!beforeUploadArgs.Cancel)
{
// Create new meta file
MetaFileInfo mfi = new MetaFileInfo(uploader.PostedFile, ObjectID, ObjectType, Category)
{
MetaFileSiteID = SiteID
};
// Save meta file
MetaFileInfoProvider.SetMetaFileInfo(mfi);
// Set currently handled meta file
CurrentlyHandledMetaFile = mfi;
// Fire after upload event
if (OnAfterUpload != null)
{
OnAfterUpload(this, EventArgs.Empty);
}
// Reload grid data
gridFiles.ReloadData();
}
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
}
}
