/// <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>
/// Checks and processes the dependencies of the meta file and related SKU file that is being deleted.
/// Returns true if the related SKU file object that is being deleted has no existing dependencies and it can be deleted, otherwise returns false.
/// </summary>
private bool ProcessDeleteForExistingEproduct()
{
MetaFileInfo metaFile = fileListElem.CurrentlyHandledMetaFile;
DataSet skuFiles = SKUFileInfoProvider.GetSKUFiles(String.Format("FileMetaFileGUID = '{0}'", metaFile.MetaFileGUID), null);
if (!DataHelper.DataSourceIsEmpty(skuFiles))
{
SKUFileInfo skuFile = new SKUFileInfo(skuFiles.Tables[0].Rows[0]);
if (skuFile != null)
{
if (!SKUFileInfoProvider.CheckDependencies(skuFile))
{
SKUFileInfoProvider.DeleteSKUFileInfo(skuFile);
}
else
{
ErrorMessage = GetString("ecommerce.deletedisabled");
return(false);
}
}
}
return(true);
}
/// <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);
}
void fileListElem_OnBeforeDelete(object sender, CancelEventArgs e)
{
// Get meta file that is being deleted
MetaFileInfo mfi = this.fileListElem.CurrentlyHandledMetaFile;
// Get SKU files with meta file's GUID
DataSet skuFiles = SKUFileInfoProvider.GetSKUFiles(String.Format("FileMetaFileGUID = '{0}'", mfi.MetaFileGUID), null);
if (!DataHelper.DataSourceIsEmpty(skuFiles))
{
// Get SKU file
SKUFileInfo skufi = new SKUFileInfo(skuFiles.Tables[0].Rows[0]);
if (skufi != null)
{
// If SKU file has no dependencies
if (!SKUFileInfoProvider.CheckDependencies(skufi))
{
// Delete SKU file information
SKUFileInfoProvider.DeleteSKUFileInfo(skufi);
}
else
{
// Set error message about existing dependency
this.ErrorMessage = this.GetString("ecommerce.deletedisabled");
this.lblAttachmentError.Text = this.ErrorMessage;
// Cancel delete
e.Cancel = true;
}
}
}
}
/// <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);
}
}
protected void Page_Load(object sender, EventArgs e)
{
// Set default error message
var errorMessageResString = "getproductfile.existerror";
// Get order item SKU file
var token = QueryHelper.GetGuid("token", Guid.Empty);
var orderedFile = OrderItemSKUFileInfoProvider.GetOrderItemSKUFileInfo(token);
if (orderedFile != null)
{
// Get parent order item
var orderItem = OrderItemInfoProvider.GetOrderItemInfo(orderedFile.OrderItemID);
if (orderItem != null)
{
// If download is not expired
if ((orderItem.OrderItemValidTo.CompareTo(DateTimeHelper.ZERO_TIME) == 0) || (orderItem.OrderItemValidTo.CompareTo(DateTime.Now) > 0))
{
// Get SKU file
var skuFile = SKUFileInfoProvider.GetSKUFileInfo(orderedFile.FileID);
if (skuFile != null)
{
// Decide how to process the file based on file type
switch (skuFile.FileType.ToLowerCSafe())
{
case "metafile":
// Set parameters to current context
Context.Items["fileguid"] = skuFile.FileMetaFileGUID;
Context.Items["disposition"] = "attachment";
// Handle request using metafile handler
Response.Clear();
var handler = new GetMetaFileHandler();
handler.ProcessRequest(Context);
Response.End();
return;
}
}
}
else
{
// Set error message
errorMessageResString = "getproductfile.expirederror";
}
}
}
// Perform server side redirect to error page
Response.Clear();
Server.Transfer(UIHelper.GetErrorPageUrl("getproductfile.error", errorMessageResString));
Response.End();
}
/// <summary>
/// Checks and processes the dependencies of the meta file and related SKU file that is being deleted.
/// Returns true if the related SKU file object that is being deleted has no existing dependencies and it can be deleted, otherwise returns false.
/// </summary>
private bool ProcessDeleteForExistingEproduct()
{
MetaFileInfo metaFile = fileListElem.CurrentlyHandledMetaFile;
DataSet skuFiles = SKUFileInfoProvider.GetSKUFiles().WhereEquals("FileMetaFileGUID", metaFile.MetaFileGUID);
if (!DataHelper.DataSourceIsEmpty(skuFiles))
{
SKUFileInfo skuFile = new SKUFileInfo(skuFiles.Tables[0].Rows[0]);
if (skuFile.Generalized.CheckDependencies())
{
ErrorMessage = ECommerceHelper.GetDependencyMessage(skuFile);
return(false);
}
SKUFileInfoProvider.DeleteSKUFileInfo(skuFile);
}
return(true);
}
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);
}
}
protected void Page_Load(object sender, EventArgs e)
{
string errorMessage = null;
// Get order item SKU file
OrderItemSKUFileInfo oiskufi = OrderItemSKUFileInfoProvider.GetOrderItemSKUFileInfo(token);
if (oiskufi != null)
{
// Get parent order item
OrderItemInfo oii = OrderItemInfoProvider.GetOrderItemInfo(oiskufi.OrderItemID);
if (oii != null)
{
// If download is not expired
if ((oii.OrderItemValidTo.CompareTo(DateTimeHelper.ZERO_TIME) == 0) || (oii.OrderItemValidTo.CompareTo(DateTime.Now) > 0))
{
// Get SKU file
SKUFileInfo skufi = SKUFileInfoProvider.GetSKUFileInfo(oiskufi.FileID);
if (skufi != null)
{
// Decide how to process the file based on file type
switch (skufi.FileType.ToLowerCSafe())
{
case "metafile":
// Set parameters to current context
Context.Items["fileguid"] = skufi.FileMetaFileGUID;
Context.Items["disposition"] = "attachment";
// Perform server side redirect to download
Response.Clear();
Server.Transfer(URLHelper.ResolveUrl("~/CMSPages/GetMetaFile.aspx"));
Response.End();
return;
}
}
}
else
{
// Set error message
errorMessage = ResHelper.GetString("getproductfile.expirederror");
}
}
}
// If error message not set
if (String.IsNullOrEmpty(errorMessage))
{
// Set default error message
errorMessage = ResHelper.GetString("getproductfile.existerror");
}
// Set error message to current context
Context.Items["title"] = ResHelper.GetString("getproductfile.error");
Context.Items["text"] = errorMessage;
// Perform server side redirect to error page
Response.Clear();
Server.Transfer(URLHelper.ResolveUrl("~/CMSMessages/Error.aspx"));
Response.End();
}
/// <summary>
/// Saves edited SKU and returns it's ID. In case of error 0 is returned. Does not fire product saved event.
/// </summary>
private int SaveInternal()
{
// Check permissions
this.CheckModifyPermission();
// If form is valid and enabled
if (this.Validate() && this.FormEnabled)
{
bool newItem = false;
// Get SKUInfo
SKUInfo skuiObj = SKUInfoProvider.GetSKUInfo(mProductId);
if (skuiObj == null)
{
newItem = true;
// Create new item -> insert
skuiObj = new SKUInfo();
skuiObj.SKUSiteID = editedSiteId;
}
else
{
SKUProductTypeEnum oldProductType = skuiObj.SKUProductType;
SKUProductTypeEnum newProductType = SKUInfoProvider.GetSKUProductTypeEnum((string)this.selectProductTypeElem.Value);
// Remove e-product dependencies if required
if ((oldProductType == SKUProductTypeEnum.EProduct) && (newProductType != SKUProductTypeEnum.EProduct))
{
// Delete meta files
MetaFileInfoProvider.DeleteFiles(skuiObj.SKUID, ECommerceObjectType.SKU, MetaFileInfoProvider.OBJECT_CATEGORY_EPRODUCT);
// Delete SKU files
DataSet skuFiles = SKUFileInfoProvider.GetSKUFiles("FileSKUID = " + skuiObj.SKUID, null);
foreach (DataRow skuFile in skuFiles.Tables[0].Rows)
{
SKUFileInfo skufi = new SKUFileInfo(skuFile);
SKUFileInfoProvider.DeleteSKUFileInfo(skufi);
}
}
// Remove bundle dependencies if required
if ((oldProductType == SKUProductTypeEnum.Bundle) && (newProductType != SKUProductTypeEnum.Bundle))
{
// Delete SKU to bundle mappings
DataSet bundles = BundleInfoProvider.GetBundles("BundleID = " + skuiObj.SKUID, null);
foreach (DataRow bundle in bundles.Tables[0].Rows)
{
BundleInfo bi = new BundleInfo(bundle);
BundleInfoProvider.DeleteBundleInfo(bi);
}
}
}
skuiObj.SKUName = this.txtSKUName.Text.Trim();
skuiObj.SKUNumber = this.txtSKUNumber.Text.Trim();
skuiObj.SKUDescription = this.htmlTemplateBody.ResolvedValue;
skuiObj.SKUPrice = this.txtSKUPrice.Value;
skuiObj.SKUEnabled = this.chkSKUEnabled.Checked;
skuiObj.SKUInternalStatusID = this.internalStatusElem.InternalStatusID;
skuiObj.SKUDepartmentID = this.departmentElem.DepartmentID;
skuiObj.SKUManufacturerID = this.manufacturerElem.ManufacturerID;
skuiObj.SKUPublicStatusID = this.publicStatusElem.PublicStatusID;
skuiObj.SKUSupplierID = this.supplierElem.SupplierID;
skuiObj.SKUSellOnlyAvailable = this.chkSKUSellOnlyAvailable.Checked;
skuiObj.SKUNeedsShipping = this.chkNeedsShipping.Checked;
skuiObj.SKUWeight = ValidationHelper.GetDouble(this.txtSKUWeight.Text.Trim(), 0);
skuiObj.SKUHeight = ValidationHelper.GetDouble(this.txtSKUHeight.Text.Trim(), 0);
skuiObj.SKUWidth = ValidationHelper.GetDouble(this.txtSKUWidth.Text.Trim(), 0);
skuiObj.SKUDepth = ValidationHelper.GetDouble(this.txtSKUDepth.Text.Trim(), 0);
skuiObj.SKUConversionName = ValidationHelper.GetString(this.ucConversion.Value, String.Empty);
skuiObj.SKUConversionValue = this.txtConversionValue.Text.Trim();
if (String.IsNullOrEmpty(this.txtSKUAvailableItems.Text.Trim()))
{
skuiObj.SetValue("SKUAvailableItems", null);
}
else
{
skuiObj.SKUAvailableItems = ValidationHelper.GetInteger(this.txtSKUAvailableItems.Text.Trim(), 0);
}
if (String.IsNullOrEmpty(this.txtSKUAvailableInDays.Text.Trim()))
{
skuiObj.SetValue("SKUAvailableInDays", null);
}
else
{
skuiObj.SKUAvailableInDays = ValidationHelper.GetInteger(this.txtSKUAvailableInDays.Text.Trim(), 0);
}
if (String.IsNullOrEmpty(this.txtMaxOrderItems.Text.Trim()))
{
skuiObj.SetValue("SKUMaxItemsInOrder", null);
}
else
{
skuiObj.SKUMaxItemsInOrder = ValidationHelper.GetInteger(this.txtMaxOrderItems.Text.Trim(), 0);
}
if (!ProductOrdered)
{
// Set product type
skuiObj.SKUProductType = SKUInfoProvider.GetSKUProductTypeEnum((string)this.selectProductTypeElem.Value);
}
// Clear product type specific properties
skuiObj.SetValue("SKUMembershipGUID", null);
skuiObj.SetValue("SKUValidity", null);
skuiObj.SetValue("SKUValidFor", null);
skuiObj.SetValue("SKUValidUntil", null);
skuiObj.SetValue("SKUMaxDownloads", null);
skuiObj.SetValue("SKUBundleInventoryType", null);
skuiObj.SetValue("SKUPrivateDonation", null);
skuiObj.SetValue("SKUMinPrice", null);
skuiObj.SetValue("SKUMaxPrice", null);
// Set product type specific properties
switch (skuiObj.SKUProductType)
{
// Set membership specific properties
case SKUProductTypeEnum.Membership:
skuiObj.SKUMembershipGUID = this.membershipElem.MembershipGUID;
skuiObj.SKUValidity = this.membershipElem.MembershipValidity;
if (skuiObj.SKUValidity == ValidityEnum.Until)
{
skuiObj.SKUValidUntil = this.membershipElem.MembershipValidUntil;
}
else
{
skuiObj.SKUValidFor = this.membershipElem.MembershipValidFor;
}
break;
// Set e-product specific properties
case SKUProductTypeEnum.EProduct:
skuiObj.SKUValidity = this.eProductElem.EProductValidity;
if (skuiObj.SKUValidity == ValidityEnum.Until)
{
skuiObj.SKUValidUntil = this.eProductElem.EProductValidUntil;
}
else
{
skuiObj.SKUValidFor = this.eProductElem.EProductValidFor;
}
break;
// Set donation specific properties
case SKUProductTypeEnum.Donation:
skuiObj.SKUPrivateDonation = this.donationElem.DonationIsPrivate;
if (this.donationElem.MinimumDonationAmount == 0.0)
{
skuiObj.SetValue("SKUMinPrice", null);
}
else
{
skuiObj.SKUMinPrice = this.donationElem.MinimumDonationAmount;
}
if (this.donationElem.MaximumDonationAmount == 0.0)
{
skuiObj.SetValue("SKUMaxPrice", null);
}
else
{
skuiObj.SKUMaxPrice = this.donationElem.MaximumDonationAmount;
}
break;
// Set bundle specific properties
case SKUProductTypeEnum.Bundle:
skuiObj.SKUBundleInventoryType = this.bundleElem.RemoveFromInventory;
break;
}
// When creating new product option
if ((this.ProductID == 0) && (this.OptionCategoryID > 0))
{
skuiObj.SKUOptionCategoryID = this.OptionCategoryID;
}
if ((newItem) && (!SKUInfoProvider.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Ecommerce, VersionActionEnum.Insert)))
{
lblError.Visible = true;
lblError.Text = GetString("ecommerceproduct.versioncheck");
return(0);
}
SKUInfoProvider.SetSKUInfo(skuiObj);
if (newItem)
{
if (ECommerceSettings.UseMetaFileForProductImage)
{
// Get allowed extensions
string settingKey = (skuiObj.IsGlobal) ? "CMSUploadExtensions" : (CMSContext.CurrentSiteName + ".CMSUploadExtensions");
string allowedExtensions = SettingsKeyProvider.GetStringValue(settingKey);
// Get posted file
HttpPostedFile file = this.ucMetaFile.PostedFile;
if ((file != null) && (file.ContentLength > 0))
{
// Get file extension
string extension = Path.GetExtension(file.FileName);
// Check if file is an image and its extension is allowed
if (ImageHelper.IsImage(extension) && (String.IsNullOrEmpty(allowedExtensions) || FileHelper.CheckExtension(extension, allowedExtensions)))
{
// Upload SKU image meta file
this.ucMetaFile.ObjectID = skuiObj.SKUID;
this.ucMetaFile.UploadFile();
// Update SKU image path
this.UpdateSKUImagePath(skuiObj);
}
else
{
// Set error message
string error = ValidationHelper.GetString(SessionHelper.GetValue("NewProductError"), null);
error += ";" + String.Format(this.GetString("com.productedit.invalidproductimage"), extension);
SessionHelper.SetValue("NewProductError", error);
}
}
}
else
{
skuiObj.SKUImagePath = this.imgSelect.Value;
}
// Upload initial e-product file
if (skuiObj.SKUProductType == SKUProductTypeEnum.EProduct)
{
this.eProductElem.SKUID = skuiObj.SKUID;
this.eProductElem.UploadNewProductFile();
}
}
else
{
// Update SKU image path
UpdateSKUImagePath(skuiObj);
}
SKUInfoProvider.SetSKUInfo(skuiObj);
if ((mNodeId > 0) && (mProductId == 0))
{
TreeProvider tree = new TreeProvider(CMSContext.CurrentUser);
TreeNode node = tree.SelectSingleNode(mNodeId, TreeProvider.ALL_CULTURES);
node.NodeSKUID = skuiObj.SKUID;
node.Update();
// Update search index for node
if ((node.PublishedVersionExists) && (SearchIndexInfoProvider.SearchEnabled))
{
SearchTaskInfoProvider.CreateTask(SearchTaskTypeEnum.Update, PredefinedObjectType.DOCUMENT, SearchHelper.ID_FIELD, node.GetSearchID());
}
// Log synchronization
DocumentSynchronizationHelper.LogDocumentChange(node, TaskTypeEnum.UpdateDocument, tree);
// Ensure new SKU values
SKUInfoProvider.SetSKUInfo(skuiObj);
}
// If SKU is of bundle product type and bundle does not exist yet
if ((skuiObj.SKUProductType == SKUProductTypeEnum.Bundle) && (this.bundleElem.BundleID == 0))
{
// Set bundle ID
this.bundleElem.BundleID = skuiObj.SKUID;
// Save selected products
this.bundleElem.SaveProductsSelectionChanges();
}
this.ProductID = skuiObj.SKUID;
// Reload form
this.LoadData(skuiObj);
// Set changes saved message
this.lblInfo.Text = this.GetString("general.changessaved");
return(ValidationHelper.GetInteger(skuiObj.SKUID, 0));
}
else
{
return(0);
}
}
