private string DeleteProperty(HHPrincipal principal, HttpContext context, ref bool result)
{
string msg = string.Empty;
if (principal.IsInRole("ProductCategoryModule-Delete"))
{
DataActionStatus s = ProductProperties.Delete(context.Request["propertyID"]);
switch (s)
{
case DataActionStatus.Success:
msg = "已成功删除所选的产品分类属性！";
result = true;
break;
case DataActionStatus.RelationshipExist:
result = false;
msg = "产品分类属性下存在关联数据[子分类]，无法被删除！";
break;
case DataActionStatus.UnknownFailure:
result = false;
msg = "删除产品分类属性时发生了未知的错误！";
break;
}
}
else
{
throw new Exception("您没有执行此操作的权限！");
}
return(msg);
}
string DeleteA(HHPrincipal principal, HttpContext context, ref bool result)
{
string msg = string.Empty;
if (principal.IsInRole("ArticleModule-Delete"))
{
DataActionStatus s = ArticleManager.DeleteArticles(context.Request["newsIds"]);
switch (s)
{
case DataActionStatus.Success:
msg = "已成功删除所选的资讯！";
result = true;
break;
case DataActionStatus.RelationshipExist:
result = false;
msg = "资讯下存在关联数据[子分类/资讯]，无法被删除！";
break;
case DataActionStatus.UnknownFailure:
result = false;
msg = "删除资讯信息时发生了未知的错误！";
break;
}
}
else
{
throw new Exception("您没有执行此操作的权限！");
}
return(msg);
}
string DeleteUser(HHPrincipal principal, HttpContext context, ref bool result)
{
string msg = string.Empty;
if (principal.IsInRole("UserModule-Delete"))
{
DataActionStatus s = Users.DeleteUsers(context.Request["userid"]);
switch (s)
{
case DataActionStatus.Success:
msg = "已成功删除所选的用户信息！";
result = true;
break;
case DataActionStatus.UnknownFailure:
result = false;
msg = "删除用户信息时发生了未知的错误！";
break;
}
}
else
{
throw new Exception("您没有执行此操作的权限！");
}
return(msg);
}
string DeleteOrg(HHPrincipal principal, HttpContext context, ref bool result)
{
string msg = string.Empty;
if (principal.IsInRole("OrganizeModule-Delete"))
{
DataActionStatus s = Organizations.DeleteOrganization(context.Request["orgid"]);
switch (s)
{
case DataActionStatus.Success:
msg = "已成功删除所选的组织结构！";
result = true;
break;
case DataActionStatus.RelationshipExist:
result = false;
msg = "部门组织结构下存在关联数据[部门/用户]，无法被删除！";
break;
case DataActionStatus.UnknownFailure:
result = false;
msg = "删除组织结构信息时发生了未知的错误！";
break;
}
}
else
{
throw new Exception("您没有执行此操作的权限！");
}
return(msg);
}
protected void btnPost_Click(object sender, EventArgs e)
{
try
{
int id = int.Parse(Request.QueryString["ID"]);
ArticleCategory cat = ArticleManager.GetArticleCategory(id);
if (cat != null)
{
cat.Name = txtCategoryName.Text;
cat.Description = txtCategoryDesc.Text;
cat.DisplayOrder = int.Parse(txtDisplayOrder.Text);
cat.ID = id;
cat.UpdateTime = DateTime.Now;
cat.UpdateUser = Profile.AccountInfo.UserID;
DataActionStatus status = ArticleManager.UpdateArticleCategory(cat);
if (status == DataActionStatus.Success)
{
base.ExecuteJs("msg('操作成功，已成功修改此资讯分类信息！',true);", false);
}
}
}
catch (System.Exception ex)
{
}
mbMsg.ShowMsg("修改资讯分类信息失败，请联系管理员！");
}
/// <summary>
/// 添加文章
/// </summary>
/// <param name="info"></param>
/// <param name="?"></param>
/// <returns></returns>
public static Article AddArticle(Article info, out DataActionStatus status)
{
Article result = ArticleProvider.Instance.CreateUpdateArticle(info, DataProviderAction.Create, out status);
HHCache.Instance.Remove(NewsManagerCacheKey + "AllArticles");
return(result);
}
public static DataActionStatus DeleteBrand(int brandID)
{
DataActionStatus status = ShopDataProvider.Instance.DeleteBrand(brandID);
HHCache.Instance.Remove(CacheKeyManager.GetProductBrandKey(brandID));
HHCache.Instance.RemoveByPattern(CacheKeyManager.ProductBrandXpath);
OnUpdated(brandID);
return(status);
}
/// <summary>
/// 添加文章分类
/// </summary>
/// <param name="organization"></param>
/// <returns></returns>
public static ArticleCategory AddArticleCategory(ArticleCategory info, out DataActionStatus status)
{
ArticleCategory result;
result = ArticleCategoryProvider.Instance.CreateUpdateArticleCategory(info, DataProviderAction.Create, out status);
HHCache.Instance.Remove(NewsManagerCacheKey + "AllCategories");
return(result);
}
protected void btnPost_Click(object sender, EventArgs e)
{
ProductProperty property = null;
if (action == OperateType.Add)
{
property = new ProductProperty();
property.CategoryID = categoryID;
}
else
{
property = ProductProperties.GetProperty(id);
}
property.PropertyName = this.txtPropertyName.Text;
property.PropertyDesc = this.txtPropertyDesc.Text;
property.SubCategoryHidden = this.scHidden.SelectedValue;
property.DisplayOrder = Convert.ToInt32(txtDisplayOrder.Text);
if (action == OperateType.Add)
{
DataActionStatus status = ProductProperties.Create(property);
switch (status)
{
case DataActionStatus.DuplicateName:
mbMsg.ShowMsg("新增产品分类属性失败，在该分类下存在同名产品分类属性！");
break;
case DataActionStatus.UnknownFailure:
mbMsg.ShowMsg("新增产品分类属性失败，请联系管理员！");
break;
case DataActionStatus.Success:
default:
base.ExecuteJs("msg('操作成功，已成功增加一个新的产品分类属性！',true);", false);
break;
}
}
else
{
DataActionStatus status = ProductProperties.Update(property);
switch (status)
{
case DataActionStatus.DuplicateName:
mbMsg.ShowMsg("修改产品分类属性失败，在该分类下存在同名产品分类属性！");
break;
case DataActionStatus.UnknownFailure:
mbMsg.ShowMsg("修改产品分类属性失败，请联系管理员！");
break;
case DataActionStatus.Success:
default:
base.ExecuteJs("msg('操作成功，已成功修改产品分类属性！',true);", false);
break;
}
}
}
protected void btnPost_Click(object sender, EventArgs e)
{
ProductCategory category = null;
if (action == OperateType.Add)
{
category = new ProductCategory();
category.ParentID = parentID;
category.PropertyID = propertyID;
}
else
{
category = ProductCategories.GetCategory(id);
}
category.CategoryName = txtCategoryName.Text;
category.CategoryDesc = txtCategoryDesc.Text;
category.DisplayOrder = Convert.ToInt32(txtDisplayOrder.Text);
if (action == OperateType.Add)
{
DataActionStatus status = ProductCategories.Create(category);
switch (status)
{
case DataActionStatus.DuplicateName:
mbMsg.ShowMsg("新增产品分类失败，存在同名产品分类！");
break;
case DataActionStatus.UnknownFailure:
mbMsg.ShowMsg("新增产品分类失败，请联系管理员！");
break;
case DataActionStatus.Success:
default:
base.ExecuteJs("msg('操作成功，已成功增加一个新的产品分类！',true);", false);
break;
}
}
else
{
DataActionStatus status = ProductCategories.Update(category);
switch (status)
{
case DataActionStatus.DuplicateName:
mbMsg.ShowMsg("修改产品分类失败，存在同名产品分类！");
break;
case DataActionStatus.UnknownFailure:
mbMsg.ShowMsg("修改产品分类失败，请联系管理员！");
break;
case DataActionStatus.Success:
default:
base.ExecuteJs("msg('操作成功，已成功修改产品分类信息！',true);", false);
break;
}
}
}
/// <summary>
/// 清理客户级别
/// </summary>
/// <param name="userID"></param>
/// <returns></returns>
public static DataActionStatus Clear(int companyID)
{
DataActionStatus status = CommonDataProvider.Instance.ClearCustomerGrade(companyID);
if (status == DataActionStatus.Success)
{
HHCache.Instance.Remove(CacheKeyManager.GetCustomerGradeKeyByCompanyID(companyID));
}
return(status);
}
/// <summary>
/// 删除组织机构
/// <remarks>
/// 1. DataActionStatus.Success: 成功删除所有
/// 2. DataActionStatus.UnknownFailure 删除失败
/// 3. DataActionStatus.RelationshipExist 删除时组织结构下存在关联用户(无关联用户部门继续删除)
/// 即 部门组织结构下存在关联用户的，将无法被删除！
/// </remarks>
/// </summary>
/// <param name="organizationIDList">组织结构ID列，如"1,12,34"</param>
/// <returns></returns>
public static DataActionStatus DeleteOrganization(string organizationIDList)
{
DataActionStatus s = CommonDataProvider.Instance.DeleteOrganization(organizationIDList);
if (s == DataActionStatus.Success || s == DataActionStatus.RelationshipExist)
{
HHCache.Instance.Remove(CacheKeyManager.OrganizationKey);
}
return(s);
}
/// <summary>
/// 批量删除分类属性
/// </summary>
/// <param name="categoryIDList">ID列表</param>
/// <returns></returns>
public static DataActionStatus Delete(string propertyIDList)
{
DataActionStatus status = ShopDataProvider.Instance.DeleteProperty(propertyIDList);
if (status != DataActionStatus.UnknownFailure)
{
HHCache.Instance.RemoveByPattern(CacheKeyManager.ProductPropertyXpath);
}
return(status);
}
/// <summary>
/// 删除用户
/// </summary>
/// <param name="userIDList">用户ID列表,例如12,15</param>
/// <returns></returns>
public static DataActionStatus DeleteUsers(string userIDList)
{
DataActionStatus status = CommonDataProvider.Instance.DeleteUsers(userIDList);
if (status == DataActionStatus.Success || status == DataActionStatus.RelationshipExist)
{
RefreshCachedUser(null);
}
return(status);
}
public override DataActionStatus DeleteArticleAttachment(int id)
{
ELParameter idParam = new ELParameter("@AttachmentID", DbType.Int32);
idParam.Value = id;
DataActionStatus result = (DataActionStatus)Convert.ToInt32(DataHelper.ExecuteScalar(CommandType.StoredProcedure, "sp_ArticleAttachment_Delete", idParam));
return(result);
}
/// <summary>
/// 删除文章
/// </summary>
/// <param name="article"></param>
/// <returns></returns>
public override DataActionStatus DeleteArticle(int articleID)
{
ELParameter articleIDParam = new ELParameter("@ArticleID", DbType.Int32);
articleIDParam.Value = articleID;
DataActionStatus result = (DataActionStatus)Convert.ToInt32(DataHelper.ExecuteScalar(CommandType.StoredProcedure, "sp_Article_Delete", articleIDParam));
return(result);
}
/// <summary>
/// 删除文章
/// </summary>
/// <param name="article"></param>
/// <returns></returns>
public override DataActionStatus DeleteArticleCategory(int id)
{
ELParameter idParam = new ELParameter("@CategoryID", DbType.Int32);
idParam.Value = id;
DataActionStatus result = (DataActionStatus)DataHelper.ExecuteScalar(CommandType.StoredProcedure, "sp_ArticleCategory_Delete", idParam);
return(result);
}
/// <summary>
/// 删除行业信息
/// </summary>
/// <param name="industryID"></param>
public static DataActionStatus Delete(int industryID)
{
DataActionStatus status = ShopDataProvider.Instance.DeleteIndustry(industryID);
if (status == DataActionStatus.Success)
{
HHCache.Instance.RemoveByPattern(CacheKeyManager.ProductIndustryXpath);
OnUpdated(industryID);
}
return(status);
}
/// <summary>
/// 批量删除分类
/// </summary>
/// <param name="categoryIDList"></param>
/// <returns></returns>
public static DataActionStatus DeleteCategories(string categoryIDList)
{
DataActionStatus result = ArticleCategoryProvider.Instance.DeleteArticleCategories(categoryIDList);
if (result == DataActionStatus.Success)
{
HHCache.Instance.Remove(NewsManagerCacheKey + "AllCategories");
}
return(result);
}
/// <summary>
/// 删除文章
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static DataActionStatus DeleteArticle(int id)
{
DataActionStatus result = ArticleProvider.Instance.DeleteArticle(id);
if (result == DataActionStatus.Success)
{
HHCache.Instance.Remove(NewsManagerCacheKey + "AllArticles");
}
return(result);
}
/// <summary>
/// 批量删除商品分类
/// </summary>
/// <param name="categoryIDList">ID列表</param>
/// <returns></returns>
public static DataActionStatus Delete(string categoryIDList)
{
DataActionStatus status = ShopDataProvider.Instance.DeleteCategory(categoryIDList);
if (status != DataActionStatus.UnknownFailure)
{
HHCache.Instance.RemoveByPattern(CacheKeyManager.ProductCategoryXpath);
OnUpdated(categoryIDList);
}
return(status);
}
/// <summary>
/// 删除产品
/// </summary>
/// <param name="productID"></param>
/// <returns></returns>
public static DataActionStatus Delete(int productID)
{
DataActionStatus status = ShopDataProvider.Instance.DeleteProduct(productID);
if (status == DataActionStatus.Success)
{
OnUpdated();
HHCache.Instance.Remove(CacheKeyManager.GetProductKey(productID));
HHCache.Instance.Remove(CacheKeyManager.ProductListKey);
}
return(status);
}
protected void egvShowPictures_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
Guid showPictureID = (Guid)this.egvShowPictures.DataKeys[e.RowIndex].Value;
DataActionStatus status = ShowPictures.Delete(showPictureID);
switch (status)
{
default:
case DataActionStatus.Success:
BindData();
break;
}
}
/// <summary>
/// 根据ID删除产品图片信息
/// </summary>
/// <param name="pictureID"></param>
/// <returns></returns>
public static DataActionStatus Delete(int pictureID)
{
DataActionStatus status = ShopDataProvider.Instance.DeletePicture(pictureID);
if (status == DataActionStatus.Success)
{
ProductPicture picture = GetPicture(pictureID);
if (picture != null)
{
HHCache.Instance.Remove(CacheKeyManager.GetPictureKey(picture.PictureID));
HHCache.Instance.Remove(CacheKeyManager.GetPictureKeyByProductID(picture.ProductID));
}
}
return(status);
}
/// <summary>
/// 删除客户级别
/// </summary>
/// <param name="gradeID"></param>
/// <returns></returns>
public static DataActionStatus Delete(int gradeID)
{
DataActionStatus status = CommonDataProvider.Instance.DeleteCustomerGrade(gradeID);
if (status == DataActionStatus.Success)
{
CustomerGrade grade = Get(gradeID);
if (grade != null)
{
HHCache.Instance.Remove(CacheKeyManager.GetCustomerGradeKeyByCompanyID(grade.CompanyID));
HHCache.Instance.Remove(CacheKeyManager.GetCustomerGradeKey(gradeID));
}
}
return(status);
}
protected void egvProductFocus_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
int focusID = (int)egvProductFocus.DataKeys[e.RowIndex].Value;
DataActionStatus status = ProductFocusManager.Delete(focusID);
switch (status)
{
case DataActionStatus.Success:
BindData();
break;
default:
case DataActionStatus.UnknownFailure:
throw new HHException(ExceptionType.Failed, "删除失败，请确认此条记录存在，并状态正常！");
}
}
protected void egvBrands_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
int brandID = (int)egvBrands.DataKeys[e.RowIndex].Value;
DataActionStatus status = ProductBrands.DeleteBrand(brandID);
switch (status)
{
case DataActionStatus.RelationshipExist:
throw new HHException(ExceptionType.Failed, "此品牌下存在关联商品，无法直接删除(请先删除此品牌下关联商品)！");
case DataActionStatus.UnknownFailure:
throw new HHException(ExceptionType.Failed, "删除商品品牌时失败，请确认此商品品牌存在，并状态正常！");
case DataActionStatus.Success:
BindData();
break;
}
}
protected void egvArticles_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
int articleID = (int)egvArticles.DataKeys[e.RowIndex].Value;
DataActionStatus status = ArticleManager.DeleteArticle(articleID);
switch (status)
{
case DataActionStatus.RelationshipExist:
throw new HHException(ExceptionType.Failed, "此附件下存在关联数据，无法直接删除！");
case DataActionStatus.UnknownFailure:
throw new HHException(ExceptionType.Failed, "删除附件失败，请联系管理人员！");
default:
case DataActionStatus.Success:
BindData();
break;
}
}
protected void egvProducts_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
int productID = (int)egvProducts.DataKeys[e.RowIndex].Value;
DataActionStatus status = Products.Delete(productID);
switch (status)
{
case DataActionStatus.RelationshipExist:
throw new HHException(ExceptionType.Failed, "此产品信息下存在关联数据，无法直接删除！");
case DataActionStatus.UnknownFailure:
throw new HHException(ExceptionType.Failed, "删除产品信息失败，请联系管理人员！");
default:
case DataActionStatus.Success:
BindData();
break;
}
}
protected void egvAttachments_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
int attachmentID = (int)egvAttachments.DataKeys[e.RowIndex].Value;
DataActionStatus status = ArticleAttachments.DeleteAttachment(
Server.MapPath("~") + "/FileStore/" + ArticleAttachments.FileStoreKey,
attachmentID);
switch (status)
{
case DataActionStatus.RelationshipExist:
throw new HHException(ExceptionType.Failed, "此附件下存在关联数据，无法直接删除！");
case DataActionStatus.UnknownFailure:
throw new HHException(ExceptionType.Failed, "删除附件失败，请联系管理人员！");
default:
case DataActionStatus.Success:
BindData();
break;
}
}
