/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public WebApiResult<Basic_BankInfo> Add(Basic_BankInfo entity)
{
var result = new WebApiResult<Basic_BankInfo>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_BankInfo.Any(x => x.Deleted == false && x.Name == entity.Name))
{
result.AddError(string.Format("开户行全称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
DataContext.Basic_BankInfo.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public WebApiResult<Basic_Announcement> Add(Basic_Announcement entity)
{
var result = new WebApiResult<Basic_Announcement>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_Announcement.Any(x => x.Deleted == false && x.Topic == entity.Topic))
{
result.AddError(string.Format("标题 '{0}' 已经存在。", entity.Topic));
}
}
#endregion
#region 保存
if (result.Success)
{
DataContext.Basic_Announcement.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
public async Task<WebApiResult<string>> AddResourceItem()
{
WebApiResult<string> result = new WebApiResult<string>();
UploadedFilesResizer resizer = new UploadedFilesResizer();
string originalPath = resizer.configPath;
//string originalPath = System.Configuration.ConfigurationManager.AppSettings["ResourceItemPath"];
string path = originalPath;
// 检查是否是 multipart/form-data
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
HttpResponseMessage response = null;
try
{
path = HttpContext.Current.Server.MapPath(path);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
// 设置上传目录
var provider = new RenamingMultipartFormDataStreamProvider(path);
// 接收数据，并保存文件
var bodyparts = await Request.Content.ReadAsMultipartAsync(provider);
response = Request.CreateResponse(HttpStatusCode.Accepted);
FileInfo fi = new FileInfo(provider.FileData[0].LocalFileName);
if (fi.Exists)
{
try
{
Basic_ResourceItem resourceItem = new Basic_ResourceItem
{
Filename = fi.Name,
FileType = fi.Extension,
FileLength = fi.Length,
Url = string.Format("{0}{1}", originalPath, fi.Name),
CreatedAt = DateTime.Now,
Deleted = false
};
result = _resourceItemService.AddResourceitem(resourceItem);
resizer.CreateSizedImages(provider.FileData[0].LocalFileName);
fi = null;
}
catch (Exception ex)
{
result.AddError(ex.Message);
}
}
}
catch
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
return result;
}
public ActionResult GetUser()
{
var result = new WebApiResult<LoginResult>();
if (Session["current-user"] is LoginResult)
{
result.Data = Session["current-user"] as LoginResult;
}
else
{
result.AddError("当前用户未登录。");
}
return Json(result, JsonRequestBehavior.AllowGet);
}
/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public WebApiResult<Product_ProductContract> Add(Product_ProductContract entity)
{
var result = new WebApiResult<Product_ProductContract>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Product_ProductContract.Any(x => x.Deleted == false && x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var maxSortOrder = 0;
if (DataContext.Product_ProductContract.Any())
{
maxSortOrder = DataContext.Product_ProductContract.Max(x => x.SortOrder);
}
entity.SortOrder = maxSortOrder + 1;
entity.Id = Guid.NewGuid();
entity.CreatedAt = DateTime.Now;
entity.UpdatedAt = DateTime.Now;
// entity.Deleted = false;
DataContext.Product_ProductContract.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public virtual WebApiResult<Basic_Announcement> Update(Basic_Announcement entity)
{
var result = new WebApiResult<Basic_Announcement>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_Announcement.Any(x => x.Deleted == false && x.Id != entity.Id && x.Topic == entity.Topic))
{
result.AddError(string.Format("标题 '{0}' 已经存在。", entity.Topic));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Basic_Announcement.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Topic = entity.Topic;
origin.TypeId = entity.TypeId;
origin.StartDate = entity.StartDate;
origin.EndDate = entity.EndDate;
origin.Text = entity.Text;
origin.AttachmentResourceItemId = entity.AttachmentResourceItemId;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Product_ProductDefinition> result, Product_ProductDefinition entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数产品名称。");
}
//if (string.IsNullOrWhiteSpace(entity.CalType.ToString()))
//{
// result.AddError("请输入参数产品计算类型。");
//}
return result.Success;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public virtual WebApiResult<Product_ProductDefinition> Update(Product_ProductDefinition entity)
{
var result = new WebApiResult<Product_ProductDefinition>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Product_ProductDefinition.Any(x => x.Deleted == false
&& x.Id != entity.Id
&& x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Product_ProductDefinition.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Name = entity.Name;
origin.DownPayment = entity.DownPayment;
origin.Margin = entity.Margin;
origin.Fee = entity.Fee;
origin.FinalPayment = entity.FinalPayment;
origin.InterestRate = entity.InterestRate;
origin.Lease = entity.Lease;
//origin.CalType = entity.CalType;
entity.UpdatedAt = DateTime.Now;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public virtual WebApiResult<Basic_CompanyInfo> Add(Basic_CompanyInfo entity)
{
var result = new WebApiResult<Basic_CompanyInfo>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_CompanyInfo.Any(x => x.Deleted == false && x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var maxSortOrder = 0;
if (DataContext.Basic_CompanyInfo.Any())
{
maxSortOrder = DataContext.Basic_CompanyInfo.Max(x => x.SortOrder);
}
entity.SortOrder = maxSortOrder + 1;
entity.CreatedAt = DateTime.Now;
entity.CreatedById = CurrentUserId;
DataContext.Basic_CompanyInfo.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Basic_CompanyInfo> result, Basic_CompanyInfo entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数名称。");
}
return result.Success;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public WebApiResult<Basic_CompanyInfo> Update(Basic_CompanyInfo entity)
{
var result = new WebApiResult<Basic_CompanyInfo>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_CompanyInfo.Any(x => x.Deleted == false
&& x.Id != entity.Id
&& x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Basic_CompanyInfo.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Name = entity.Name;
origin.Abbreviation = entity.Abbreviation;
origin.Address = entity.Address;
origin.BusinessLicense = entity.BusinessLicense;
origin.BusinessScope = entity.BusinessScope;
origin.BusinessTerm = entity.BusinessTerm;
origin.CompanyEmail = entity.CompanyEmail;
origin.ContactAddress = entity.ContactAddress;
origin.ContactEmail = entity.ContactEmail;
origin.ContactIDCard = entity.ContactIDCard;
origin.ContactName = entity.ContactName;
origin.ContactPhone = entity.ContactPhone;
origin.Fax = entity.Fax;
origin.Founded = entity.Founded;
origin.LegaiEmail = entity.LegaiEmail;
origin.LegalAddress = entity.LegalAddress;
origin.LegalIDCard = entity.LegalIDCard;
origin.LegalName = entity.LegalName;
origin.LegalPhone = entity.LegalPhone;
origin.LegalPostalCode = entity.LegalPostalCode;
origin.LegalTel = entity.LegalTel;
origin.NameEN = entity.NameEN;
origin.Number = entity.Number;
origin.OrganizationCode = entity.OrganizationCode;
origin.PostalCode = entity.PostalCode;
origin.RegisteredAddress = entity.RegisteredAddress;
origin.RegistrationCapital = entity.RegistrationCapital;
origin.Remarks = entity.Remarks;
origin.TaxRegistrationNo = entity.TaxRegistrationNo;
origin.Telephone = entity.Telephone;
origin.TypeCode = entity.TypeCode;
origin.TypeName = entity.TypeName;
origin.UpdatedAt = DateTime.Now;
origin.ContactTel = entity.ContactTel;
origin.ContactPostalCode = entity.ContactPostalCode;
origin.CreatedById = CurrentUserId;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Product_ProductContract> result, Product_ProductContract entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数合同名称。");
}
if (string.IsNullOrWhiteSpace(entity.TemplateHtml.ToString()))
{
result.AddError("请输入参数合同内容。");
}
return result.Success;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Basic_BankInfo> result, Basic_BankInfo entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数开户行全称。");
}
if (string.IsNullOrWhiteSpace(entity.Name.ToString()))
{
result.AddError("请输入参数开户行全称。");
}
return result.Success;
}
/// <summary>
/// 验证 AuthToken 是否有效
/// </summary>
/// <param name="authToken">要验证的登录 token</param>
/// <returns>有效返回 true, 否则为 false</returns>
public virtual WebApiResult<Membership_AuthToken> ValidateAuthToken(Guid appKey, Guid authToken)
{
var result = new WebApiResult<Membership_AuthToken>();
var token = DataContext.Membership_AuthToken.FirstOrDefault(x =>
x.Id == authToken
&& x.Api_ApplicationKey.Id == appKey
&& x.Expired > DateTime.Now);
if (token == null)
{
result.AddError("认证无效或已过期，请重新登录");
}
else
{
result.Data = token;
}
return result;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public WebApiResult<Basic_DataDictionary> Update(Basic_DataDictionary entity)
{
var result = new WebApiResult<Basic_DataDictionary>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_DataDictionary.Any(x => x.Deleted == false
&& x.Id != entity.Id
&& x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Basic_DataDictionary.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Name = entity.Name;
origin.Code = entity.Code;
origin.StringValue = entity.StringValue;
origin.IntValue = entity.IntValue;
origin.FloatValue = entity.FloatValue;
origin.BoolValue = entity.BoolValue;
origin.DateTimeValue = entity.DateTimeValue;
origin.UpdatedAt = DateTime.Now;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 下移数据实体
/// </summary>
/// <param name="ids">要下移的数据实体主键列表</param>
/// <returns>成功返回 true；否则返回 false。</returns>
public WebApiResult MoveDown(Guid[] ids)
{
var result = new WebApiResult();
if (DataContext.Basic_DataDictionary.MoveDown(ids))
{
DataContext.SaveChanges();
}
else
{
result.AddError("当前已经是最末行。");
}
return result;
}
/// <summary>
/// 新建数据实体
/// </summary>
/// <param name="entity">要新建的数据实体</param>
/// <returns>返回新建的数据实体</returns>
public virtual WebApiResult<Basic_DataDictionary> Add(Basic_DataDictionary entity)
{
var result = new WebApiResult<Basic_DataDictionary>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_DataDictionary.Any(x => x.Deleted == false && x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var maxSortOrder = 0;
var code = entity.Code;
if (DataContext.Basic_DataDictionary.Any())
{
maxSortOrder = DataContext.Basic_DataDictionary.Max(x => x.SortOrder);
}
entity.SortOrder = maxSortOrder + 1;
entity.CreatedAt = DateTime.Now;
var ParentId = entity.ParentId;
if (string.IsNullOrEmpty(entity.Code) && ParentId != null)
{
entity.Code = DataContext.Basic_DataDictionary.FirstOrDefault(x => x.Id == ParentId).Code + entity.SortOrder;
}
DataContext.Basic_DataDictionary.Add(entity);
DataContext.SaveChanges();
result.Data = entity;
}
#endregion
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Basic_Announcement> result, Basic_Announcement entity)
{
if (string.IsNullOrWhiteSpace(entity.Topic))
{
result.AddError("请输入参数通知公告标题。");
}
if (string.IsNullOrWhiteSpace(entity.Text.ToString()))
{
result.AddError("请输入参数通知公告内容。");
}
return result.Success;
}
/// <summary>
/// 上移数据实体
/// </summary>
/// <param name="ids">要上移的数据实体主键列表</param>
/// <returns>成功返回 true；否则返回 false。</returns>
public WebApiResult MoveUp(Guid[] ids)
{
var result = new WebApiResult();
if (DataContext.Basic_CompanyInfo.MoveUp(ids))
{
DataContext.SaveChanges();
}
else
{
result.AddError("当前已经是第一行。");
}
return result;
}
/// <summary>
/// 验证数据实体
/// </summary>
/// <param name="result">result 参数</param>
/// <param name="entity">要验证的数据实体</param>
/// <returns>成功返回 true；否则返回 false。</returns>
protected bool Validate(WebApiResult<Basic_DataDictionary> result, Basic_DataDictionary entity)
{
if (string.IsNullOrWhiteSpace(entity.Name))
{
result.AddError("请输入参数名称。");
}
return result.Success;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public virtual WebApiResult<Product_ProductContract> Update(Product_ProductContract entity)
{
var result = new WebApiResult<Product_ProductContract>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Product_ProductContract.Any(x => x.Deleted == false
&& x.Id != entity.Id
&& x.Name == entity.Name))
{
result.AddError(string.Format("名称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Product_ProductContract.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Name = entity.Name;
origin.TemplateHtml = entity.TemplateHtml;
entity.UpdatedAt = DateTime.Now;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}
/// <summary>
/// 登录
/// </summary>
/// <param name="username">用户名/帐号</param>
/// <param name="password">密码</param>
/// <param name="remember">记住登录</param>
/// <returns>成功返回 true，失败返回错误信息</returns>
public virtual WebApiResult<LoginResult> Login(string username, string password, bool remember, Guid? appKey = null)
{
WebApiResult<LoginResult> result = new WebApiResult<LoginResult>();
Guid? innerAppKey = AppKey;
if (innerAppKey == null && appKey != null)
{
innerAppKey = appKey;
}
try
{
var loginUsername = username;
#region 登录验证
bool isExist = DataContext.Membership_User
.Any(x => (x.Username == username || x.PhoneNumber == username || x.Email == username) && x.Deleted == false);
Membership_User membershipUser = null;
if (isExist)
{
membershipUser = DataContext.Membership_User
.Where(item => (item.Username == username || item.PhoneNumber == username || item.Email == username) && item.Deleted == false)
.FirstOrDefault();
if (membershipUser.Actived)//true:禁用 false:启用
{
result.AddError("当前帐号已被禁用");
return result;
}
loginUsername = membershipUser.Username;//如果membershipuser表中存在记录，则优先使用
}
result = AuthService.Login(loginUsername, password);
if (!result.Success)
{
return result;
}
#endregion
if (!isExist)//membershipUser == null 用户中心存在记录，membershipuser表中不存在
{
membershipUser = new Membership_User
{
Username = result.Data.User.Username,
Password = "******",
DisplayName = result.Data.User.DisplayName,
Email = result.Data.User.Email,
Approved = true,
};
DataContext.Membership_User.Add(membershipUser);
DataContext.SaveChanges();
}
#region Auth Token
var applicationKey = DataContext.Api_ApplicationKey.FirstOrDefault(x => x.Id == innerAppKey);
var token = new Membership_AuthToken
{
Membership_User = membershipUser,
Api_ApplicationKey = applicationKey,
Expired = DateTime.Now.AddHours(LunzWebConfigurationManager.Membership.AuthTokenTimeout),
};
DataContext.Membership_AuthToken.Add(token);
DataContext.SaveChanges();
result.Data.Token = token.Id;
#endregion
}
catch (Exception e)
{
result.AddError(e.Message);
}
return result;
}
/// <summary>
/// 更新数据实体
/// </summary>
/// <param name="entity">要更新的数据实体</param>
/// <returns>返回更新后的数据实体</returns>
public virtual WebApiResult<Basic_BankInfo> Update(Basic_BankInfo entity)
{
var result = new WebApiResult<Basic_BankInfo>();
#region 验证
if (Validate(result, entity))
{
if (DataContext.Basic_BankInfo.Any(x => x.Deleted == false && x.Id != entity.Id && x.Name == entity.Name))
{
result.AddError(string.Format("开户行全称 '{0}' 已经存在。", entity.Name));
}
}
#endregion
#region 保存
if (result.Success)
{
var origin = DataContext.Basic_BankInfo.FirstOrDefault(x => x.Id == entity.Id);
if (origin != null)
{
origin.Name = entity.Name;
origin.TypeId = entity.TypeId;
origin.ContactPerson = entity.ContactPerson;
origin.Telephone = entity.Telephone;
origin.PostalCode = entity.PostalCode;
origin.Address = entity.Address;
DataContext.SaveChanges();
result.Data = origin;
}
}
#endregion
return result;
}