/// <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);
}
/// <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>
/// 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);
}
}
/// <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>
/// 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, MetaFileInfoProvider.OBJECT_CATEGORY_THUMBNAIL, null, null);
if (!DataHelper.DataSourceIsEmpty(ds))
{
MetaFileInfo metaFile = new MetaFileInfo(ds.Tables[0].Rows[0]);
mli.LibraryTeaserGuid = metaFile.MetaFileGUID;
mli.LibraryTeaserPath = MetaFileInfoProvider.GetMetaFileUrl(metaFile.MetaFileGUID, metaFile.MetaFileName);
}
else
{
mli.LibraryTeaserGuid = Guid.Empty;
mli.LibraryTeaserPath = String.Empty;
}
}
void fileListElem_OnAfterUpload(object sender, EventArgs e)
{
// Get uploaded meta file
MetaFileInfo mfi = this.fileListElem.CurrentlyHandledMetaFile;
SKUFileInfo skufi = null;
// Get SKU file for this meta file
DataSet skuFiles = SKUFileInfoProvider.GetSKUFiles(String.Format("FileMetaFileGUID = '{0}'", mfi.MetaFileGUID), null);
// If SKU file does not exist
if (DataHelper.DataSourceIsEmpty(skuFiles))
{
// Create new SKU file
skufi = new SKUFileInfo();
skufi.FileSKUID = this.SKUID;
skufi.FileMetaFileGUID = mfi.MetaFileGUID;
}
// If SKU file exists
else
{
// Get existing SKU file
skufi = new SKUFileInfo(skuFiles.Tables[0].Rows[0]);
}
skufi.FileName = mfi.MetaFileName;
skufi.FilePath = MetaFileInfoProvider.GetMetaFileUrl(mfi.MetaFileGUID, mfi.MetaFileName);
skufi.FileType = MediaSourceEnum.MetaFile.ToString();
// Save SKU file
SKUFileInfoProvider.SetSKUFileInfo(skufi);
// Bubble up the after upload event
if (this.OnAfterUpload != null)
{
this.OnAfterUpload(this, EventArgs.Empty);
}
}
private void UpdateSKUImagePath(SKUInfo skuObj)
{
if (ECommerceSettings.UseMetaFileForProductImage && !hasAttachmentImagePath)
{
// Update product image path according to its meta file
DataSet ds = MetaFileInfoProvider.GetMetaFiles(ucMetaFile.ObjectID, skuObj.TypeInfo.ObjectType, MetaFileInfoProvider.OBJECT_CATEGORY_IMAGE, null, null);
if (!DataHelper.DataSourceIsEmpty(ds))
{
MetaFileInfo metaFile = new MetaFileInfo(ds.Tables[0].Rows[0]);
skuObj.SKUImagePath = MetaFileInfoProvider.GetMetaFileUrl(metaFile.MetaFileGUID, metaFile.MetaFileName);
}
else
{
skuObj.SKUImagePath = "";
}
}
else
{
// Update product image path from the image selector
skuObj.SKUImagePath = imgSelect.Value;
}
}
/// <summary>
/// Gets row column content.
/// </summary>
/// <param name="dr">DataRow</param>
/// <param name="dc">DataColumn</param>
/// <param name="toCompare">Indicates if comparison will be used for content</param>
/// <returns>String with column content</returns>
private string GetRowColumnContent(DataRow dr, DataColumn dc, bool toCompare)
{
if (dr == null)
{
// Data row was not specified
return(String.Empty);
}
if (!dr.Table.Columns.Contains(dc.ColumnName))
{
// Data row does not contain the required column
return(String.Empty);
}
var value = dr[dc.ColumnName];
if (DataHelper.IsEmpty(value))
{
// Column is empty
return(String.Empty);
}
string content = null;
// Binary columns
if (dc.DataType == typeof(byte[]))
{
byte[] data = (byte[])dr[dc.ColumnName];
content = "<" + GetString("General.BinaryData") + ": " + DataHelper.GetSizeString(data.Length) + ">";
}
else
{
content = ValidationHelper.GetString(value, "");
}
// Possible DataTime columns
if (dc.DataType == typeof(DateTime))
{
DateTime dateTime = Convert.ToDateTime(content);
CultureInfo cultureInfo = new CultureInfo(CMSContext.CurrentUser.PreferredUICultureCode);
content = dateTime.ToString(cultureInfo);
}
bool standard = true;
switch (dc.ColumnName.ToLowerCSafe())
{
// Document content
case "documentcontent":
EditableItems items = new EditableItems();
items.LoadContentXml(ValidationHelper.GetString(value, ""));
StringBuilder sb = new StringBuilder();
// Add regions
foreach (DictionaryEntry region in items.EditableRegions)
{
if (toCompare)
{
sb.AppendLine((string)region.Key);
}
else
{
sb.Append("<span class=\"VersionEditableRegionTitle\">" + (string)region.Key + "</span>");
}
string regionContent = HTMLHelper.ResolveUrls((string)region.Value, URLHelper.ApplicationPath);
if (toCompare)
{
sb.AppendLine(regionContent);
}
else
{
sb.Append("<span class=\"VersionEditableRegionText\">" + HTMLHelper.HTMLEncode(regionContent) + "</span>");
}
}
// Add web parts
foreach (DictionaryEntry part in items.EditableWebParts)
{
if (toCompare)
{
sb.AppendLine((string)part.Key);
}
else
{
sb.Append("<span class=\"VersionEditableWebPartTitle\">" + (string)part.Key + "</span>");
}
string regionContent = HTMLHelper.ResolveUrls((string)part.Value, URLHelper.ApplicationPath);
if (toCompare)
{
sb.AppendLine(regionContent);
}
else
{
sb.Append("<span class=\"VersionEditableWebPartText\">" + HTMLHelper.HTMLEncode(regionContent) + "</span>");
}
}
content = sb.ToString();
standard = false;
break;
// XML columns
case "pagetemplatewebparts":
case "webpartproperties":
case "reportparameters":
case "classformdefinition":
case "classxmlschema":
case "classformlayout":
case "userdialogsconfiguration":
case "siteinvoicetemplate":
case "userlastlogoninfo":
case "formdefinition":
case "formlayout":
case "uservisibility":
case "classsearchsettings":
case "graphsettings":
case "tablesettings":
case "transformationhierarchicalxml":
case "issuetext":
case "savedreportparameters":
// HTML columns
case "emailtemplatetext":
case "templatebody":
case "templateheader":
case "templatefooter":
case "containertextbefore":
case "containertextafter":
case "savedreporthtml":
case "layoutcode":
case "webpartlayoutcode":
case "transformationcode":
case "reportlayout":
if (BrowserHelper.IsIE())
{
content = HTMLHelper.ReformatHTML(content, " ");
}
else
{
content = HTMLHelper.ReformatHTML(content);
}
break;
// File columns
case "metafilename":
{
string metaFileName = HTMLHelper.HTMLEncode(ValidationHelper.GetString(dr["MetaFileName"], ""));
if (ShowLinksForMetafiles)
{
Guid metaFileGuid = ValidationHelper.GetGuid(dr["MetaFileGuid"], Guid.Empty);
if (metaFileGuid != Guid.Empty)
{
content = "<a href=\"" + ResolveUrl(MetaFileInfoProvider.GetMetaFileUrl(metaFileGuid, metaFileName)) + "\" target=\"_blank\" >" + metaFileName + "</a>";
}
}
else
{
content = metaFileName;
}
standard = false;
}
break;
}
// Standard rendering
if (!toCompare)
{
if (standard)
{
if (EncodeDisplayedData)
{
content = HTMLHelper.HTMLEncode(content);
}
content = content.Replace("\t", " ");
content = "<div style=\"max-height: 300px; overflow: auto;\">" + content + "</div>";
}
// Ensure line ending
content = TextHelper.EnsureLineEndings(content, "<br />");
}
return(content);
}
/// <summary>
/// Gets row column content.
/// </summary>
/// <param name="dr">DataRow</param>
/// <param name="dc">DataColumn</param>
/// <param name="toCompare">Indicates if comparison will be used for content</param>
/// <returns>String with column content</returns>
private string GetRowColumnContent(DataRow dr, DataColumn dc, bool toCompare)
{
if (dr == null)
{
// Data row was not specified
return(string.Empty);
}
if (!dr.Table.Columns.Contains(dc.ColumnName))
{
// Data row does not contain the required column
return(string.Empty);
}
var value = dr[dc.ColumnName];
if (DataHelper.IsEmpty(value))
{
// Column is empty
return(string.Empty);
}
var content = ValidationHelper.GetString(value, "");
Func <string> render = () =>
{
if (toCompare)
{
return(content);
}
content = HTMLHelper.EnsureHtmlLineEndings(content);
return(content);
};
Func <string> standardRender = () =>
{
if (toCompare)
{
return(content);
}
if (EncodeDisplayedData)
{
content = HTMLHelper.HTMLEncode(content);
}
content = content.Replace("\t", " ");
content = "<div style=\"max-height: 300px; overflow: auto;\">" + content + "</div>";
content = HTMLHelper.EnsureHtmlLineEndings(content);
return(content);
};
// Binary columns
if (dc.DataType == typeof(byte[]))
{
var data = (byte[])dr[dc.ColumnName];
content = string.Format("<{0}: {1}>", GetString("General.BinaryData"), DataHelper.GetSizeString(data.Length));
return(standardRender());
}
// DataTime columns
if (dc.DataType == typeof(DateTime))
{
var dateTime = Convert.ToDateTime(content);
var cultureInfo = CultureHelper.GetCultureInfo(MembershipContext.AuthenticatedUser.PreferredUICultureCode);
content = dateTime.ToString(cultureInfo);
return(standardRender());
}
switch (dc.ColumnName.ToLowerCSafe())
{
// Document content
case "documentcontent":
var sb = new StringBuilder();
Action <MultiKeyDictionary <string>, string, string> addItems = (dictionary, titleClass, textClass) =>
{
foreach (DictionaryEntry item in dictionary)
{
var regionContent = HTMLHelper.ResolveUrls((string)item.Value, SystemContext.ApplicationPath);
if (toCompare)
{
sb.AppendLine((string)item.Key);
sb.AppendLine(regionContent);
}
else
{
sb.AppendFormat("<span class=\"{0}\">{1}</span>", titleClass, item.Key);
sb.AppendFormat("<span class=\"{0}\">{1}</span>", textClass, HTMLHelper.HTMLEncode(regionContent));
}
}
};
var items = new EditableItems();
items.LoadContentXml(ValidationHelper.GetString(value, ""));
// Add regions
addItems(items.EditableRegions, "VersionEditableRegionTitle", "VersionEditableRegionText");
// Add web parts
addItems(items.EditableWebParts, "VersionEditableWebPartTitle", "VersionEditableWebPartText");
content = sb.ToString();
return(render());
// XML columns
case "pagetemplatewebparts":
case "webpartproperties":
case "reportparameters":
case "classformdefinition":
case "classxmlschema":
case "classformlayout":
case "userdialogsconfiguration":
case "siteinvoicetemplate":
case "userlastlogoninfo":
case "formdefinition":
case "formlayout":
case "classsearchsettings":
case "graphsettings":
case "tablesettings":
case "issuetext":
case "issuewidgets":
case "savedreportparameters":
case "emailwidgetproperties":
// HTML columns
case "emailtemplatetext":
case "emailwidgetcode":
case "templatebody":
case "templateheader":
case "templatefooter":
case "containertextbefore":
case "containertextafter":
case "savedreporthtml":
case "layoutcode":
case "webpartlayoutcode":
case "transformationcode":
case "reportlayout":
#pragma warning disable CS0618 // Type or member is obsolete
if (BrowserHelper.IsIE())
#pragma warning restore CS0618 // Type or member is obsolete
{
content = HTMLHelper.ReformatHTML(content, " ");
}
else
{
content = HTMLHelper.ReformatHTML(content);
}
break;
// File columns
case "metafilename":
var metaFileName = HTMLHelper.HTMLEncode(ValidationHelper.GetString(dr["MetaFileName"], ""));
if (ShowLinksForMetafiles)
{
var metaFileGuid = ValidationHelper.GetGuid(dr["MetaFileGuid"], Guid.Empty);
if (metaFileGuid != Guid.Empty)
{
var metaFileUrl = ResolveUrl(MetaFileInfoProvider.GetMetaFileUrl(metaFileGuid, metaFileName));
content = string.Format("<a href=\"{0}\" target=\"_blank\">{1}</a>", metaFileUrl, metaFileName);
}
}
else
{
content = metaFileName;
}
return(render());
}
return(standardRender());
}
/// <summary>
/// Processes the content.
/// </summary>
/// <param name="sb">StringBuilder to write</param>
/// <param name="source">Source object</param>
/// <param name="column">Column</param>
/// <param name="content">Content</param>
protected void ProcessContent(StringBuilder sb, object source, string column, ref string content)
{
bool standard = true;
switch (column.ToLowerCSafe())
{
// Document content
case "documentcontent":
EditableItems items = new EditableItems();
items.LoadContentXml(content);
// Add regions
foreach (DictionaryEntry region in items.EditableRegions)
{
sb.Append("<span class=\"VersionEditableRegionTitle\">" + (string)region.Key + "</span>");
string regionContent = HTMLHelper.ResolveUrls((string)region.Value, SystemContext.ApplicationPath);
sb.Append("<span class=\"VersionEditableRegionText\">" + regionContent + "</span>");
}
// Add web parts
foreach (DictionaryEntry part in items.EditableWebParts)
{
sb.Append("<span class=\"VersionEditableWebPartTitle\">" + (string)part.Key + "</span>");
string regionContent = HTMLHelper.ResolveUrls((string)part.Value, SystemContext.ApplicationPath);
sb.Append("<span class=\"VersionEditableWebPartText\">" + regionContent + "</span>");
}
standard = false;
break;
// XML columns
case "pagetemplatewebparts":
case "webpartproperties":
case "reportparameters":
case "classformdefinition":
case "classxmlschema":
case "classformlayout":
case "userdialogsconfiguration":
content = HTMLHelper.ReformatHTML(content);
break;
// File columns
case "metafilename":
{
Guid metaFileGuid = ValidationHelper.GetGuid(GetValueFromSource(source, "MetaFileGuid"), Guid.Empty);
if (metaFileGuid != Guid.Empty)
{
string metaFileName = ValidationHelper.GetString(GetValueFromSource(source, "MetaFileName"), "");
content = "<a href=\"" + ResolveUrl(MetaFileInfoProvider.GetMetaFileUrl(metaFileGuid, metaFileName)) + "\" target=\"_blank\" >" + HTMLHelper.HTMLEncode(metaFileName) + "</a>";
sb.Append(content);
standard = false;
}
}
break;
}
// Standard rendering
if (standard)
{
if (content.Length > 500)
{
content = TextHelper.EnsureMaximumLineLength(content, 50, "​", true);
}
else
{
content = HTMLHelper.HTMLEncode(content);
}
content = TextHelper.EnsureHTMLLineEndings(content);
content = content.Replace("\t", " ");
sb.Append("<div style=\"max-height: 300px; overflow: auto;\">" + content + "</div>");
}
}
/// <summary>
/// Saves SKU data and returns created SKU object.
/// </summary>
public SKUInfo SaveData()
{
// Check permissions
if (SiteID > 0)
{
if (!ECommerceContext.IsUserAuthorizedForPermission("ModifyProducts"))
{
RedirectToAccessDenied("CMS.Ecommerce", "EcommerceModify OR ModifyProducts");
}
}
else
{
if (!ECommerceContext.IsUserAuthorizedForPermission("EcommerceGlobalModify"))
{
RedirectToAccessDenied("CMS.Ecommerce", "EcommerceGlobalModify");
}
}
if ((plcSKUControls.Visible) && (this.Node != null))
{
// Create empty SKU object
SKUInfo skuObj = new SKUInfo();
// Set SKU site id
skuObj.SKUSiteID = SiteID;
// Set SKU Name
if (plcSKUName.Visible)
{
skuObj.SKUName = txtSKUName.Text.Trim();
}
else
{
string skuNameField = GetDocumentMappedField("SKUName");
skuObj.SKUName = ValidationHelper.GetString(this.Node.GetValue(skuNameField), "");
}
// Set SKU price
if (plcSKUPrice.Visible)
{
skuObj.SKUPrice = txtSKUPrice.Value;
}
else
{
string skuPriceField = GetDocumentMappedField("SKUPrice");
skuObj.SKUPrice = ValidationHelper.GetDouble(this.Node.GetValue(skuPriceField), 0);
}
// Set SKU image path according to the document binding
if (!plcMetaFile.Visible && !plcImagePath.Visible)
{
string skuImageField = GetDocumentMappedField("SKUImagePath");
skuObj.SKUImagePath = ValidationHelper.GetString(this.Node.GetValue(skuImageField), "");
}
// Set SKU description
if (plcSKUDescription.Visible)
{
skuObj.SKUDescription = htmlSKUDescription.Value;
}
else
{
string skuDescriptionField = GetDocumentMappedField("SKUDescription");
skuObj.SKUDescription = ValidationHelper.GetString(this.Node.GetValue(skuDescriptionField), "");
}
// Set SKU department
skuObj.SKUDepartmentID = departmentElem.DepartmentID;
skuObj.SKUEnabled = true;
// Create new SKU
SKUInfoProvider.SetSKUInfo(skuObj);
if ((plcImagePath.Visible || plcMetaFile.Visible) && (skuObj.SKUID > 0))
{
if (ECommerceSettings.UseMetaFileForProductImage)
{
// Save meta file
ucMetaFile.ObjectID = skuObj.SKUID;
ucMetaFile.ObjectType = ECommerceObjectType.SKU;
ucMetaFile.Category = MetaFileInfoProvider.OBJECT_CATEGORY_IMAGE;
ucMetaFile.UploadFile();
// Update product image path according to its meta file
DataSet ds = MetaFileInfoProvider.GetMetaFiles(ucMetaFile.ObjectID, skuObj.TypeInfo.ObjectType);
if (!DataHelper.DataSourceIsEmpty(ds))
{
// Set product image path
MetaFileInfo metaFile = new MetaFileInfo(ds.Tables[0].Rows[0]);
skuObj.SKUImagePath = MetaFileInfoProvider.GetMetaFileUrl(metaFile.MetaFileGUID, metaFile.MetaFileName);
}
}
else
{
skuObj.SKUImagePath = this.imgSelect.Value;
}
// Update product
SKUInfoProvider.SetSKUInfo(skuObj);
}
return(skuObj);
}
return(null);
}
