/// <summary>
/// EventHandler called when <paramref name="inlineUrl"/> was edited by user
/// </summary>
private void UpdateAlternativeUrlFromInline(InlineEditingTextBox inlineUrl, int altUrlId)
{
var alternativeUrl = GetAlternativeUrlInfo(inlineUrl.Text, altUrlId);
if (alternativeUrl == null)
{
return;
}
var error = SaveData(alternativeUrl);
if (!string.IsNullOrEmpty(error))
{
inlineUrl.ErrorText = error;
ShowError(error);
return;
}
var completeUrl = $"{SitePresentationUrl}{alternativeUrl.AlternativeUrlUrl}";
SetOpenUrlAction(altUrlId, completeUrl);
inlineUrl.FormattedText = completeUrl;
ShowChangesSaved();
// Force redraw of full grid to make sure sorting is correct after inline edit
gridUrls.ReloadData();
}
private void UpdateUrlPathFromInline(InlineEditingTextBox inlineEditingTextBox, string urlPathCulture)
{
var newSlug = inlineEditingTextBox.Text;
if (String.IsNullOrWhiteSpace(newSlug))
{
ShowError(GetString("general.requiresvalue"));
return;
}
if (new PageUrlPathSlugUpdater(Node, urlPathCulture).TryUpdate(newSlug, out var collisions))
{
DocumentManager.ClearContentChanged();
gridUrlsPaths.ReloadData();
ShowChangesSaved();
if (!urlPathCulture.Equals(LocalizationContext.PreferredCultureCode, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
UpdateLiveSiteButtonUrl();
}
else
{
ShowCollisionErrorMessage(collisions);
inlineEditingTextBox.ErrorText = ResHelper.GetString("content.ui.properties.pageurlpaths.inlineedit.conflict");
}
}
protected object gridUrls_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerInvariant())
{
case "openurl":
{
var row = (DataRowView)((GridViewRow)parameter).DataItem;
var altUrlId = DataHelper.GetIntValue(row.Row, "AlternativeUrlID");
mOpenUrlActions[altUrlId] = (CMSGridActionButton)sender;
}
break;
case "url":
{
var row = (DataRowView)parameter;
var altUrl = DataHelper.GetStringValue(row.Row, "AlternativeUrlUrl");
var altUrlId = DataHelper.GetIntValue(row.Row, "AlternativeUrlID");
var completeUrl = $"{SitePresentationUrl}{altUrl}";
SetOpenUrlAction(altUrlId, completeUrl);
if (!CanManageAlternativeURLs)
{
return(HTMLHelper.HTMLEncode(completeUrl));
}
var inlineUrl = new InlineEditingTextBox
{
Text = altUrl,
FormattedText = completeUrl,
MaxLength = 450,
AdditionalCssClass = "inline-editing-textbox-wide",
EnableEditingOnTextClick = false
};
inlineUrl.Update += (s, e) => UpdateAlternativeUrlFromInline(inlineUrl, altUrlId);
if (altUrlId == mEditedUrlId)
{
inlineUrl.Load += (s, e) => inlineUrl.SwitchToEditMode();
}
return(inlineUrl);
}
}
return(parameter);
}
private InlineEditingTextBox GetInlineEditingControl(DataRowView dataRowView, string urlPath, string completeUrl)
{
var urlPathId = DataHelper.GetIntValue(dataRowView.Row, "PageUrlPathID");
var urlPathCulture = DataHelper.GetStringValue(dataRowView.Row, "PageUrlPathCulture");
var inlineEditingTextBox = new InlineEditingTextBox
{
Text = GetUrlPathSlug(urlPath),
FormattedText = completeUrl,
MaxLength = PageUrlPath.SLUG_LENGTH,
AdditionalCssClass = "inline-editing-textbox-wide inline-editing-row-container",
EnableEditingOnTextClick = false,
ToolTip = completeUrl
};
inlineEditingTextBox.Update += (s, e) => UpdateUrlPathFromInline(inlineEditingTextBox, urlPathCulture);
if (urlPathId == editedUrlPathId)
{
inlineEditingTextBox.Load += (s, e) => inlineEditingTextBox.SwitchToEditMode();
}
return(inlineEditingTextBox);
}
protected object ugVariants_OnExternalDataBound(object sender, string sourceName, object parameter)
{
DataRowView variantRow = parameter as DataRowView;
SKUInfo variant = null;
if (variantRow != null)
{
variant = new SKUInfo(variantRow.Row);
}
switch (sourceName.ToLowerCSafe())
{
case "skuname":
// Ensure correct values for unigrid export
if (sender == null)
{
return(HTMLHelper.HTMLEncode(variant.SKUName));
}
InlineEditingTextBox inlineSkuName = new InlineEditingTextBox
{
Text = variant.SKUName,
AdditionalCssClass = "inline-editing-textbox-text"
};
inlineSkuName.Formatting += (s, e) =>
{
// Localize name
inlineSkuName.FormattedText = ResHelper.LocalizeString(variant.SKUName);
};
inlineSkuName.Update += (s, e) =>
{
CheckProductModifyAndRedirect(Product);
// Trim text
inlineSkuName.Text = inlineSkuName.Text.Trim();
// Update name, if it is not empty
if (!string.IsNullOrEmpty(inlineSkuName.Text))
{
variant.SKUName = inlineSkuName.Text;
variant.MakeComplete(true);
variant.Update();
ugVariants.ReloadData();
}
else
{
inlineSkuName.ErrorText = GetString("general.requiresvalue");
}
};
return(inlineSkuName);
case "skunumber":
// Ensure correct values for unigrid export
if (sender == null)
{
return(HTMLHelper.HTMLEncode(variant.SKUNumber));
}
InlineEditingTextBox inlineSkuNumber = new InlineEditingTextBox
{
Text = variant.SKUNumber,
AdditionalCssClass = "inline-editing-textbox-text"
};
inlineSkuNumber.Update += (s, e) =>
{
CheckProductModifyAndRedirect(Product);
variant.SKUNumber = inlineSkuNumber.Text;
variant.MakeComplete(true);
variant.Update();
ugVariants.ReloadData();
};
return(inlineSkuNumber);
case "skuprice":
// Ensure correct values for unigrid export
if (sender == null)
{
return(variant.SKUPrice);
}
InlineEditingTextBox inlineSkuPrice = new InlineEditingTextBox();
inlineSkuPrice.Text = variant.SKUPrice.ToString();
inlineSkuPrice.Formatting += (s, e) =>
{
// Format price
inlineSkuPrice.FormattedText = CurrencyInfoProvider.GetFormattedPrice(variant.SKUPrice, variant.SKUSiteID);
};
inlineSkuPrice.Update += (s, e) =>
{
CheckProductModifyAndRedirect(Product);
// Price must be double number
double price = ValidationHelper.GetDouble(inlineSkuPrice.Text, -1);
if (ValidationHelper.IsDouble(inlineSkuPrice.Text) && (price >= 0))
{
variant.SKUPrice = price;
variant.MakeComplete(true);
variant.Update();
ugVariants.ReloadData();
}
else
{
inlineSkuPrice.ErrorText = GetString("com.productedit.priceinvalid");
}
};
return(inlineSkuPrice);
case "skuavailableitems":
// Ensure correct values for unigrid export
if (sender == null)
{
return(variant.SKUAvailableItems);
}
int availableItems = variant.SKUAvailableItems;
InlineEditingTextBox inlineSkuAvailableItems = new InlineEditingTextBox();
inlineSkuAvailableItems.Text = availableItems.ToString();
inlineSkuAvailableItems.EnableEncode = false;
inlineSkuAvailableItems.Formatting += (s, e) =>
{
var reorderAt = variant.SKUReorderAt;
// Emphasize the number when product needs to be reordered
if (availableItems <= reorderAt)
{
// Format message informing about insufficient stock level
string reorderMsg = string.Format(GetString("com.sku.reorderatTooltip"), reorderAt);
string message = string.Format("<span class=\"alert-status-error\" onclick=\"UnTip()\" onmouseout=\"UnTip()\" onmouseover=\"Tip('{1}')\">{0}</span>", availableItems, reorderMsg);
inlineSkuAvailableItems.FormattedText = message;
}
};
inlineSkuAvailableItems.Update += (s, e) =>
{
CheckProductModifyAndRedirect(Product);
var newNumberOfItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
// Update available items if new value is valid
if (ValidationHelper.IsInteger(inlineSkuAvailableItems.Text) && (-1000000000 <= newNumberOfItems) && (newNumberOfItems <= 1000000000))
{
variant.SKUAvailableItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
variant.MakeComplete(true);
variant.Update();
ugVariants.ReloadData();
}
else
{
inlineSkuAvailableItems.ErrorText = GetString("com.productedit.availableitemsinvalid");
}
};
return(inlineSkuAvailableItems);
}
return(parameter);
}
private object grid_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerInvariant())
{
case "skuprice":
var optionRow = parameter as DataRowView;
var option = new SKUInfo(optionRow.Row);
var currency = CurrencyInfoProvider.GetMainCurrency(option.SKUSiteID);
var formattedValue = CurrencyInfoProvider.GetFormattedValue(option.SKUPrice, currency);
if (sender == null)
{
return(formattedValue);
}
var inlineSkuPrice = new InlineEditingTextBox
{
Text = formattedValue,
FormattedText = CurrencyInfoProvider.GetRelativelyFormattedPrice(option.SKUPrice, currency)
};
inlineSkuPrice.Update += (s, e) =>
{
CheckModifyPermission();
// Update price if new value is valid
if (ValidationHelper.IsDecimal(inlineSkuPrice.Text))
{
var price = ValidationHelper.GetDecimal(inlineSkuPrice.Text, option.SKUPrice);
var validationMessage = ValidatePrice(price, currency, option);
if (string.IsNullOrEmpty(validationMessage))
{
// Round the price to according to the currency configuration
option.SKUPrice = Service.Resolve <IRoundingServiceFactory>()
.GetRoundingService(SiteContext.CurrentSiteID)
.Round(price, currency);
option.MakeComplete(true);
option.Update();
ugOptions.ReloadData();
}
else
{
inlineSkuPrice.ErrorText = validationMessage;
}
}
else
{
inlineSkuPrice.ErrorText = String.Format(GetString("com.productedit.priceinvalid"), currency.CurrencyCode, currency.CurrencyRoundTo);
}
};
return(inlineSkuPrice);
case "skuavailableitems":
var row = parameter as DataRowView;
var optionStock = new SKUInfo(row.Row);
int availableItems = optionStock.SKUAvailableItems;
// Inventory tracking disabled
if (optionStock.SKUTrackInventory == TrackInventoryTypeEnum.Disabled)
{
return(GetString("com.inventory.nottracked"));
}
// Ensure correct values for unigrid export
if (sender == null)
{
return(availableItems);
}
var inlineSkuAvailableItems = new InlineEditingTextBox
{
Text = availableItems.ToString(),
EnableEncode = false
};
inlineSkuAvailableItems.Formatting += (s, e) =>
{
var reorderAt = optionStock.SKUReorderAt;
// Emphasize the number when product needs to be reordered
if (availableItems <= reorderAt)
{
// Format message informing about insufficient stock level
string reorderMsg = string.Format(GetString("com.sku.reorderatTooltip"), reorderAt);
string message = string.Format("<span class=\"alert-status-error\" onclick=\"UnTip()\" onmouseout=\"UnTip()\" onmouseover=\"Tip('{1}')\">{0}</span>", availableItems, reorderMsg);
inlineSkuAvailableItems.FormattedText = message;
}
};
inlineSkuAvailableItems.Update += (s, e) =>
{
CheckModifyPermission();
var newNumberOfItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
// Update available items if new value is valid
if (ValidationHelper.IsInteger(inlineSkuAvailableItems.Text) && (-1000000000 <= newNumberOfItems) && (newNumberOfItems <= 1000000000))
{
optionStock.SKUAvailableItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
optionStock.MakeComplete(true);
optionStock.Update();
ugOptions.ReloadData();
}
else
{
inlineSkuAvailableItems.ErrorText = GetString("com.productedit.availableitemsinvalid");
}
};
return(inlineSkuAvailableItems);
case "delete":
case "move":
{
var button = sender as CMSGridActionButton;
if (button != null)
{
// Hide actions when not allowed
button.Visible = allowActions;
}
}
break;
}
return(parameter);
}
private object grid_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerCSafe())
{
case "skuprice":
var optionRow = parameter as DataRowView;
var option = new SKUInfo(optionRow.Row);
if (sender == null)
{
return option.SKUPrice;
}
var inlineSkuPrice = new InlineEditingTextBox();
inlineSkuPrice.Text = option.SKUPrice.ToString();
inlineSkuPrice.Formatting += (s, e) =>
{
// Format price
inlineSkuPrice.FormattedText = CurrencyInfoProvider.GetRelativelyFormattedPrice(option.SKUPrice, option.SKUSiteID);
};
inlineSkuPrice.Update += (s, e) =>
{
CheckModifyPermission();
CheckDepartmentPermission(option.SKUDepartmentID);
var valid = false;
var price = option.SKUPrice;
// Update price if new value is valid
if (ValidationHelper.IsDouble(inlineSkuPrice.Text))
{
price = ValidationHelper.GetDouble(inlineSkuPrice.Text, option.SKUPrice);
// Accessory price can not be negative
if (!option.IsAccessoryProduct || !(price < 0.0))
{
valid = true;
}
}
if (valid)
{
option.SKUPrice = price;
option.MakeComplete(true);
option.Update();
ugOptions.ReloadData();
}
else
{
inlineSkuPrice.ErrorText = GetString("com.productedit.priceinvalid");
}
};
return inlineSkuPrice;
case "skuavailableitems":
var row = parameter as DataRowView;
var optionStock = new SKUInfo(row.Row);
int availableItems = optionStock.SKUAvailableItems;
// Inventory tracking disabled
if (optionStock.SKUTrackInventory == TrackInventoryTypeEnum.Disabled)
{
return GetString("com.inventory.nottracked");
}
// Ensure correct values for unigrid export
if (sender == null)
{
return availableItems;
}
var inlineSkuAvailableItems = new InlineEditingTextBox();
inlineSkuAvailableItems.Text = availableItems.ToString();
inlineSkuAvailableItems.EnableEncode = false;
inlineSkuAvailableItems.Formatting += (s, e) =>
{
var reorderAt = optionStock.SKUReorderAt;
// Emphasize the number when product needs to be reordered
if (availableItems <= reorderAt)
{
// Format message informing about insufficient stock level
string reorderMsg = string.Format(GetString("com.sku.reorderatTooltip"), reorderAt);
string message = string.Format("<span class=\"alert-status-error\" onclick=\"UnTip()\" onmouseout=\"UnTip()\" onmouseover=\"Tip('{1}')\">{0}</span>", availableItems, reorderMsg);
inlineSkuAvailableItems.FormattedText = message;
}
};
inlineSkuAvailableItems.Update += (s, e) =>
{
CheckModifyPermission();
CheckDepartmentPermission(optionStock.SKUDepartmentID);
var newNumberOfItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
// Update available items if new value is valid
if (ValidationHelper.IsInteger(inlineSkuAvailableItems.Text) && (-1000000000 <= newNumberOfItems) && (newNumberOfItems <= 1000000000))
{
optionStock.SKUAvailableItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
optionStock.MakeComplete(true);
optionStock.Update();
ugOptions.ReloadData();
}
else
{
inlineSkuAvailableItems.ErrorText = GetString("com.productedit.availableitemsinvalid");
}
};
return inlineSkuAvailableItems;
case "delete":
case "moveup":
case "movedown":
{
CMSGridActionButton button = sender as CMSGridActionButton;
if (button != null)
{
// Hide actions when not allowed
button.Visible = allowActions;
}
}
break;
}
return parameter;
}
private object gridData_OnExternalDataBound(object sender, string sourceName, object parameter)
{
DataRowView row = parameter as DataRowView;
if (DocumentListingDisplayed)
{
switch (sourceName.ToLowerCSafe())
{
case "skunumber":
case "skuavailableitems":
case "publicstatusid":
case "allowforsale":
case "skusiteid":
case "typename":
case "skuprice":
if (ShowSections && (row["NodeSKUID"] == DBNull.Value))
{
return NO_DATA_CELL_VALUE;
}
break;
case "edititem":
row = ((GridViewRow)parameter).DataItem as DataRowView;
if ((row != null) && ((row["NodeSKUID"] == DBNull.Value) || showProductsInTree))
{
CMSGridActionButton btn = sender as CMSGridActionButton;
if (btn != null)
{
int currentNodeId = ValidationHelper.GetInteger(row["NodeID"], 0);
int nodeParentId = ValidationHelper.GetInteger(row["NodeParentID"], 0);
if (row["NodeSKUID"] == DBNull.Value)
{
btn.IconCssClass = "icon-eye";
btn.IconStyle = GridIconStyle.Allow;
btn.ToolTip = GetString("com.sku.viewproducts");
}
// Go to the selected document
btn.OnClientClick = "EditItem(" + currentNodeId + ", " + nodeParentId + "); return false;";
}
}
break;
}
}
switch (sourceName.ToLowerCSafe())
{
case "skunumber":
string skuNumber = ValidationHelper.GetString(row["SKUNumber"], null);
return HTMLHelper.HTMLEncode(ResHelper.LocalizeString(skuNumber) ?? "");
case "skuavailableitems":
var sku = new SKUInfo(row.Row);
int availableItems = sku.SKUAvailableItems;
// Inventory tracked by variants
if (sku.SKUTrackInventory == TrackInventoryTypeEnum.ByVariants)
{
return GetString("com.inventory.trackedbyvariants");
}
// Inventory tracking disabled
if (sku.SKUTrackInventory == TrackInventoryTypeEnum.Disabled)
{
return GetString("com.inventory.nottracked");
}
// Ensure correct values for unigrid export
if (sender == null)
{
return availableItems;
}
// Tracking by products
InlineEditingTextBox inlineAvailableItems = new InlineEditingTextBox();
inlineAvailableItems.Text = availableItems.ToString();
inlineAvailableItems.DelayedReload = DocumentListingDisplayed;
inlineAvailableItems.EnableEncode = false;
inlineAvailableItems.Formatting += (s, e) =>
{
var reorderAt = sku.SKUReorderAt;
// Emphasize the number when product needs to be reordered
if (availableItems <= reorderAt)
{
// Format message informing about insufficient stock level
string reorderMsg = string.Format(GetString("com.sku.reorderatTooltip"), reorderAt);
string message = string.Format("<span class=\"alert-status-error\" onclick=\"UnTip()\" onmouseout=\"UnTip()\" onmouseover=\"Tip('{1}')\">{0}</span>", availableItems, reorderMsg);
inlineAvailableItems.FormattedText = message;
}
};
// Unigrid with delayed reload in combination with inline edit control requires additional postback to sort data.
// Update data only if external data bound is called for the first time.
if (!forceReloadData)
{
inlineAvailableItems.Update += (s, e) =>
{
var newNumberOfItems = ValidationHelper.GetInteger(inlineAvailableItems.Text, availableItems);
if (ValidationHelper.IsInteger(inlineAvailableItems.Text) && (-1000000000 <= newNumberOfItems) && (newNumberOfItems <= 1000000000))
{
CheckModifyPermission(sku);
// Ensures that grid will display inserted value
sku.SKUAvailableItems = newNumberOfItems;
// Document list is used to display products -> document has to be updated to ensure correct sku mapping
if (DocumentListingDisplayed)
{
int documentId = ValidationHelper.GetInteger(row.Row["DocumentID"], 0);
// Create an instance of the Tree provider and select edited document with coupled data
TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser);
TreeNode document = tree.SelectSingleDocument(documentId);
if (document == null)
{
return;
}
document.SetValue("SKUAvailableItems", newNumberOfItems);
document.Update();
forceReloadData = true;
}
// Stand-alone product -> only product has to be updated
else
{
sku.MakeComplete(true);
sku.Update();
gridData.ReloadData();
}
}
else
{
inlineAvailableItems.ErrorText = GetString("com.productedit.availableitemsinvalid");
}
};
}
return inlineAvailableItems;
case "skuprice":
SKUInfo product = new SKUInfo(row.Row);
// Ensure correct values for unigrid export
if (sender == null)
{
return product.SKUPrice;
}
InlineEditingTextBox inlineSkuPrice = new InlineEditingTextBox();
inlineSkuPrice.Text = product.SKUPrice.ToString();
inlineSkuPrice.DelayedReload = DocumentListingDisplayed;
inlineSkuPrice.Formatting += (s, e) =>
{
// Format price
inlineSkuPrice.FormattedText = CurrencyInfoProvider.GetFormattedPrice(product.SKUPrice, product.SKUSiteID);
};
// Unigrid with delayed reload in combination with inline edit control requires additional postback to sort data.
// Update data only if external data bound is called for the first time.
if (!forceReloadData)
{
inlineSkuPrice.Update += (s, e) =>
{
CheckModifyPermission(product);
// Price must be a double number
double price = ValidationHelper.GetDouble(inlineSkuPrice.Text, -1);
if (ValidationHelper.IsDouble(inlineSkuPrice.Text) && (price >= 0))
{
// Ensures that grid will display inserted price
product.SKUPrice = price;
// Document list is used to display products -> document has to be updated to ensure correct sku mapping
if (DocumentListingDisplayed)
{
int documentId = ValidationHelper.GetInteger(row.Row["DocumentID"], 0);
// Create an instance of the Tree provider and select edited document with coupled data
TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser);
TreeNode document = tree.SelectSingleDocument(documentId);
if (document != null)
{
document.SetValue("SKUPrice", price);
document.Update();
forceReloadData = true;
}
}
// Stand-alone product -> only product has to be updated
else
{
product.MakeComplete(true);
product.Update();
gridData.ReloadData();
}
}
else
{
inlineSkuPrice.ErrorText = GetString("com.productedit.priceinvalid");
}
};
}
return inlineSkuPrice;
case "publicstatusid":
int id = ValidationHelper.GetInteger(row["SKUPublicStatusID"], 0);
PublicStatusInfo publicStatus = PublicStatusInfoProvider.GetPublicStatusInfo(id);
if (publicStatus != null)
{
// Localize and encode
return HTMLHelper.HTMLEncode(ResHelper.LocalizeString(publicStatus.PublicStatusDisplayName));
}
return string.Empty;
case "allowforsale":
// Get "on sale" flag
return UniGridFunctions.ColoredSpanYesNo(ValidationHelper.GetBoolean(row["SKUEnabled"], false));
case "typename":
string docTypeName = ValidationHelper.GetString(row["ClassDisplayName"], null);
// Localize class display name
if (!string.IsNullOrEmpty(docTypeName))
{
return HTMLHelper.HTMLEncode(ResHelper.LocalizeString(docTypeName));
}
return string.Empty;
}
return parameter;
}
private object gridData_OnExternalDataBound(object sender, string sourceName, object parameter)
{
DataRowView row = parameter as DataRowView;
if (DocumentListingDisplayed)
{
switch (sourceName.ToLowerInvariant())
{
case "skunumber":
case "skuavailableitems":
case "publicstatusid":
case "allowforsale":
case "skusiteid":
case "typename":
case "skuprice":
if (ShowSections && (row["NodeSKUID"] == DBNull.Value))
{
return(NO_DATA_CELL_VALUE);
}
break;
case "edititem":
row = ((GridViewRow)parameter).DataItem as DataRowView;
if ((row != null) && ((row["NodeSKUID"] == DBNull.Value) || showProductsInTree))
{
CMSGridActionButton btn = sender as CMSGridActionButton;
if (btn != null)
{
int currentNodeId = ValidationHelper.GetInteger(row["NodeID"], 0);
int nodeParentId = ValidationHelper.GetInteger(row["NodeParentID"], 0);
if (row["NodeSKUID"] == DBNull.Value)
{
btn.IconCssClass = "icon-eye";
btn.IconStyle = GridIconStyle.Allow;
btn.ToolTip = GetString("com.sku.viewproducts");
}
// Go to the selected document
btn.OnClientClick = "EditItem(" + currentNodeId + ", " + nodeParentId + "); return false;";
}
}
break;
}
}
switch (sourceName.ToLowerInvariant())
{
case "skunumber":
string skuNumber = ValidationHelper.GetString(row["SKUNumber"], null);
return(HTMLHelper.HTMLEncode(ResHelper.LocalizeString(skuNumber) ?? ""));
case "skuavailableitems":
var sku = new SKUInfo(row.Row);
int availableItems = sku.SKUAvailableItems;
// Inventory tracked by variants
if (sku.SKUTrackInventory == TrackInventoryTypeEnum.ByVariants)
{
return(GetString("com.inventory.trackedbyvariants"));
}
// Inventory tracking disabled
if (sku.SKUTrackInventory == TrackInventoryTypeEnum.Disabled)
{
return(GetString("com.inventory.nottracked"));
}
// Ensure correct values for unigrid export
if (sender == null)
{
return(availableItems);
}
// Tracking by products
var inlineAvailableItems = new InlineEditingTextBox
{
Text = availableItems.ToString(),
DelayedReload = DocumentListingDisplayed,
EnableEncode = false
};
inlineAvailableItems.Formatting += (s, e) =>
{
var reorderAt = sku.SKUReorderAt;
// Emphasize the number when product needs to be reordered
if (availableItems <= reorderAt)
{
// Format message informing about insufficient stock level
string reorderMsg = string.Format(GetString("com.sku.reorderatTooltip"), reorderAt);
string message = string.Format("<span class=\"alert-status-error\" onclick=\"UnTip()\" onmouseout=\"UnTip()\" onmouseover=\"Tip('{1}')\">{0}</span>", availableItems, reorderMsg);
inlineAvailableItems.FormattedText = message;
}
};
// Unigrid with delayed reload in combination with inline edit control requires additional postback to sort data.
// Update data only if external data bound is called for the first time.
if (!forceReloadData)
{
inlineAvailableItems.Update += (s, e) =>
{
var newNumberOfItems = ValidationHelper.GetInteger(inlineAvailableItems.Text, availableItems);
if (ValidationHelper.IsInteger(inlineAvailableItems.Text) && (-1000000000 <= newNumberOfItems) && (newNumberOfItems <= 1000000000))
{
CheckModifyPermission(sku);
// Ensures that grid will display inserted value
sku.SKUAvailableItems = newNumberOfItems;
// Document list is used to display products -> document has to be updated to ensure correct sku mapping
if (DocumentListingDisplayed)
{
int documentId = ValidationHelper.GetInteger(row.Row["DocumentID"], 0);
// Create an instance of the Tree provider and select edited document with coupled data
var tree = new TreeProvider(MembershipContext.AuthenticatedUser);
var document = tree.SelectSingleDocument(documentId);
if (document == null)
{
return;
}
document.SetValue("SKUAvailableItems", newNumberOfItems);
document.Update();
forceReloadData = true;
}
// Stand-alone product -> only product has to be updated
else
{
sku.MakeComplete(true);
sku.Update();
gridData.ReloadData();
}
}
else
{
inlineAvailableItems.ErrorText = GetString("com.productedit.availableitemsinvalid");
}
};
}
return(inlineAvailableItems);
case "skuprice":
var product = new SKUInfo(row.Row);
var currency = CurrencyInfoProvider.GetMainCurrency(product.SKUSiteID);
var formattedValue = CurrencyInfoProvider.GetFormattedValue(product.SKUPrice, currency);
// Ensure correct values for unigrid export
if (sender == null)
{
return(formattedValue);
}
var inlineSkuPrice = new InlineEditingTextBox
{
Text = formattedValue,
FormattedText = CurrencyInfoProvider.GetFormattedPrice(product.SKUPrice, currency),
DelayedReload = DocumentListingDisplayed
};
// Unigrid with delayed reload in combination with inline edit control requires additional postback to sort data.
// Update data only if external data bound is called for the first time.
if (!forceReloadData)
{
inlineSkuPrice.Update += (s, e) =>
{
CheckModifyPermission(product);
var price = ValidationHelper.GetDecimal(inlineSkuPrice.Text, -1);
var error = ValidatePrice(price, currency, product);
if (String.IsNullOrEmpty(error))
{
UpdatePrice(product, price, row.Row);
}
else
{
inlineSkuPrice.ErrorText = error;
}
};
}
return(inlineSkuPrice);
case "publicstatusid":
int id = ValidationHelper.GetInteger(row["SKUPublicStatusID"], 0);
PublicStatusInfo publicStatus = PublicStatusInfoProvider.GetPublicStatusInfo(id);
if (publicStatus != null)
{
// Localize and encode
return(HTMLHelper.HTMLEncode(ResHelper.LocalizeString(publicStatus.PublicStatusDisplayName)));
}
return(string.Empty);
case "allowforsale":
// Get "on sale" flag
return(UniGridFunctions.ColoredSpanYesNo(ValidationHelper.GetBoolean(row["SKUEnabled"], false)));
case "typename":
string docTypeName = ValidationHelper.GetString(row["ClassDisplayName"], null);
// Localize class display name
if (!string.IsNullOrEmpty(docTypeName))
{
return(HTMLHelper.HTMLEncode(ResHelper.LocalizeString(docTypeName)));
}
return(string.Empty);
}
return(parameter);
}
protected object ugVariants_OnExternalDataBound(object sender, string sourceName, object parameter)
{
DataRowView variantRow = parameter as DataRowView;
SKUInfo variant = null;
if (variantRow != null)
{
variant = new SKUInfo(variantRow.Row);
}
switch (sourceName.ToLowerCSafe())
{
case "skuname":
// Ensure correct values for unigrid export
if (sender == null)
{
return HTMLHelper.HTMLEncode(variant.SKUName);
}
InlineEditingTextBox inlineSkuName = new InlineEditingTextBox
{
Text = variant.SKUName,
AdditionalCssClass = "inline-editing-textbox-text"
};
inlineSkuName.Formatting += (s, e) =>
{
// Localize name
inlineSkuName.FormattedText = ResHelper.LocalizeString(variant.SKUName);
};
inlineSkuName.Update += (s, e) =>
{
CheckProductModifyAndRedirect(Product);
// Trim text
inlineSkuName.Text = inlineSkuName.Text.Trim();
// Update name, if it is not empty
if (!string.IsNullOrEmpty(inlineSkuName.Text))
{
variant.SKUName = inlineSkuName.Text;
variant.MakeComplete(true);
variant.Update();
ugVariants.ReloadData();
}
else
{
inlineSkuName.ErrorText = GetString("general.requiresvalue");
}
};
return inlineSkuName;
case "skunumber":
// Ensure correct values for unigrid export
if (sender == null)
{
return HTMLHelper.HTMLEncode(variant.SKUNumber);
}
InlineEditingTextBox inlineSkuNumber = new InlineEditingTextBox
{
Text = variant.SKUNumber,
AdditionalCssClass = "inline-editing-textbox-text"
};
inlineSkuNumber.Update += (s, e) =>
{
CheckProductModifyAndRedirect(Product);
variant.SKUNumber = inlineSkuNumber.Text;
variant.MakeComplete(true);
variant.Update();
ugVariants.ReloadData();
};
return inlineSkuNumber;
case "skuprice":
// Ensure correct values for unigrid export
if (sender == null)
{
return variant.SKUPrice;
}
InlineEditingTextBox inlineSkuPrice = new InlineEditingTextBox();
inlineSkuPrice.Text = variant.SKUPrice.ToString();
inlineSkuPrice.Formatting += (s, e) =>
{
// Format price
inlineSkuPrice.FormattedText = CurrencyInfoProvider.GetFormattedPrice(variant.SKUPrice, variant.SKUSiteID);
};
inlineSkuPrice.Update += (s, e) =>
{
CheckProductModifyAndRedirect(Product);
// Price must be double number
double price = ValidationHelper.GetDouble(inlineSkuPrice.Text, -1);
if (ValidationHelper.IsDouble(inlineSkuPrice.Text) && (price >= 0))
{
variant.SKUPrice = price;
variant.MakeComplete(true);
variant.Update();
ugVariants.ReloadData();
}
else
{
inlineSkuPrice.ErrorText = GetString("com.productedit.priceinvalid");
}
};
return inlineSkuPrice;
case "skuavailableitems":
// Ensure correct values for unigrid export
if (sender == null)
{
return variant.SKUAvailableItems;
}
int availableItems = variant.SKUAvailableItems;
InlineEditingTextBox inlineSkuAvailableItems = new InlineEditingTextBox();
inlineSkuAvailableItems.Text = availableItems.ToString();
inlineSkuAvailableItems.EnableEncode = false;
inlineSkuAvailableItems.Formatting += (s, e) =>
{
var reorderAt = variant.SKUReorderAt;
// Emphasize the number when product needs to be reordered
if (availableItems <= reorderAt)
{
// Format message informing about insufficient stock level
string reorderMsg = string.Format(GetString("com.sku.reorderatTooltip"), reorderAt);
string message = string.Format("<span class=\"alert-status-error\" onclick=\"UnTip()\" onmouseout=\"UnTip()\" onmouseover=\"Tip('{1}')\">{0}</span>", availableItems, reorderMsg);
inlineSkuAvailableItems.FormattedText = message;
}
};
inlineSkuAvailableItems.Update += (s, e) =>
{
CheckProductModifyAndRedirect(Product);
var newNumberOfItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
// Update available items if new value is valid
if (ValidationHelper.IsInteger(inlineSkuAvailableItems.Text) && (-1000000000 <= newNumberOfItems) && (newNumberOfItems <= 1000000000))
{
variant.SKUAvailableItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
variant.MakeComplete(true);
variant.Update();
ugVariants.ReloadData();
}
else
{
inlineSkuAvailableItems.ErrorText = GetString("com.productedit.availableitemsinvalid");
}
};
return inlineSkuAvailableItems;
}
return parameter;
}
protected object ugDiscounts_OnExternalDataBound(object sender, string sourceName, object parameter)
{
DataRowView discountRow = parameter as DataRowView;
DiscountInfo discountInfo = null;
if (discountRow != null)
{
discountInfo = new DiscountInfo(discountRow.Row);
}
switch (sourceName.ToLowerCSafe())
{
// Append to a value field char '%' or site currency in case of flat discount
case "value":
if ((DiscountType == DiscountApplicationEnum.Shipping) && (!discountInfo.DiscountIsFlat) && (discountInfo.DiscountValue == 100))
{
return(GetString("general.free"));
}
return((discountInfo.DiscountIsFlat) ? CurrencyInfoProvider.GetFormattedPrice(discountInfo.DiscountValue, discountInfo.DiscountSiteID) : discountInfo.DiscountValue + "%");
// Display discount status
case "status":
return(discountInfo.DiscountStatus.ToLocalizedString("com.discountstatus"));
case "discountorder":
// Ensure correct values for unigrid export
if (sender == null)
{
return(discountInfo.DiscountOrder);
}
else
{
InlineEditingTextBox txtDiscountOrder = new InlineEditingTextBox();
txtDiscountOrder.Text = discountInfo.DiscountOrder.ToString();
txtDiscountOrder.Update += (s, e) =>
{
CheckModifyPermission();
// Discount order must be double number
double order = ValidationHelper.GetDouble(txtDiscountOrder.Text, -1);
// Update price if new value is valid, must be higher or equal 1
if (order >= 1)
{
discountInfo.DiscountOrder = order;
discountInfo.MakeComplete(true);
discountInfo.Update();
ugDiscounts.ReloadData();
}
else
{
txtDiscountOrder.ErrorText = GetString("com.discountedit.weightinvalid");
}
};
return(txtDiscountOrder);
}
case "application":
// Display blank value if discount don't use coupons
if ((discountInfo == null) || !discountInfo.DiscountUsesCoupons)
{
return(String.Empty);
}
var tr = new ObjectTransformation("CouponsCounts", discountInfo.DiscountID)
{
DataProvider = couponCountsDataProvider,
Transformation = "{% FormatString(GetResourceString(\"com.couponcode.appliedxofy\"), Convert.ToString(Uses, \"0\"), (UnlimitedCodeCount != 0)? GetResourceString(\"com.couponcode.unlimited\") : Convert.ToString(Limit, \"0\")) %}",
NoDataTransformation = "{$com.discount.notcreated$}",
EncodeOutput = false
};
return(tr);
case "orderamount":
double totalPriceInMainCurrency = ValidationHelper.GetDouble(discountInfo.DiscountItemMinOrderAmount, 0);
// Display blank value in the discount listing if order amount is not configured
if (totalPriceInMainCurrency == 0)
{
return(string.Empty);
}
// Format currency
string priceInMainCurrencyFormatted = CurrencyInfoProvider.GetFormattedPrice(totalPriceInMainCurrency, SiteContext.CurrentSiteID);
return(HTMLHelper.HTMLEncode(priceInMainCurrencyFormatted));
}
return(parameter);
}
private object grid_OnExternalDataBound(object sender, string sourceName, object parameter)
{
switch (sourceName.ToLowerCSafe())
{
case "skuprice":
var optionRow = parameter as DataRowView;
var option = new SKUInfo(optionRow.Row);
if (sender == null)
{
return(option.SKUPrice);
}
var inlineSkuPrice = new InlineEditingTextBox();
inlineSkuPrice.Text = option.SKUPrice.ToString();
inlineSkuPrice.Formatting += (s, e) =>
{
// Format price
inlineSkuPrice.FormattedText = CurrencyInfoProvider.GetRelativelyFormattedPrice(option.SKUPrice, option.SKUSiteID);
};
inlineSkuPrice.Update += (s, e) =>
{
CheckModifyPermission();
CheckDepartmentPermission(option.SKUDepartmentID);
var valid = false;
var price = option.SKUPrice;
// Update price if new value is valid
if (ValidationHelper.IsDouble(inlineSkuPrice.Text))
{
price = ValidationHelper.GetDouble(inlineSkuPrice.Text, option.SKUPrice);
// Accessory price can not be negative
if (!option.IsAccessoryProduct || !(price < 0.0))
{
valid = true;
}
}
if (valid)
{
option.SKUPrice = price;
option.MakeComplete(true);
option.Update();
ugOptions.ReloadData();
}
else
{
inlineSkuPrice.ErrorText = GetString("com.productedit.priceinvalid");
}
};
return(inlineSkuPrice);
case "skuavailableitems":
var row = parameter as DataRowView;
var optionStock = new SKUInfo(row.Row);
int availableItems = optionStock.SKUAvailableItems;
// Inventory tracking disabled
if (optionStock.SKUTrackInventory == TrackInventoryTypeEnum.Disabled)
{
return(GetString("com.inventory.nottracked"));
}
// Ensure correct values for unigrid export
if (sender == null)
{
return(availableItems);
}
var inlineSkuAvailableItems = new InlineEditingTextBox();
inlineSkuAvailableItems.Text = availableItems.ToString();
inlineSkuAvailableItems.EnableEncode = false;
inlineSkuAvailableItems.Formatting += (s, e) =>
{
var reorderAt = optionStock.SKUReorderAt;
// Emphasize the number when product needs to be reordered
if (availableItems <= reorderAt)
{
// Format message informing about insufficient stock level
string reorderMsg = string.Format(GetString("com.sku.reorderatTooltip"), reorderAt);
string message = string.Format("<span class=\"alert-status-error\" onclick=\"UnTip()\" onmouseout=\"UnTip()\" onmouseover=\"Tip('{1}')\">{0}</span>", availableItems, reorderMsg);
inlineSkuAvailableItems.FormattedText = message;
}
};
inlineSkuAvailableItems.Update += (s, e) =>
{
CheckModifyPermission();
CheckDepartmentPermission(optionStock.SKUDepartmentID);
var newNumberOfItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
// Update available items if new value is valid
if (ValidationHelper.IsInteger(inlineSkuAvailableItems.Text) && (-1000000000 <= newNumberOfItems) && (newNumberOfItems <= 1000000000))
{
optionStock.SKUAvailableItems = ValidationHelper.GetInteger(inlineSkuAvailableItems.Text, availableItems);
optionStock.MakeComplete(true);
optionStock.Update();
ugOptions.ReloadData();
}
else
{
inlineSkuAvailableItems.ErrorText = GetString("com.productedit.availableitemsinvalid");
}
};
return(inlineSkuAvailableItems);
case "delete":
case "moveup":
case "movedown":
{
CMSGridActionButton button = sender as CMSGridActionButton;
if (button != null)
{
// Hide actions when not allowed
button.Visible = allowActions;
}
}
break;
}
return(parameter);
}
