/// <summary>
/// Called on the IO thread when the browser needs credentials from the user.
/// </summary>
/// <param name="isProxy">Indicates whether the <paramref name="host"/> is a proxy server.</param>
/// <param name="host">The hostname.</param>
/// <param name="port">The port number.</param>
/// <param name="realm">
/// The realm is used to describe the protected area or to indicate the scope of protection.
/// </param>
/// <param name="scheme">The authentication scheme.</param>
/// <param name="callback">
/// The callback used to asynchronous continuation/cancellation of authentication requests.
/// </param>
/// <returns>
/// Return true to continue the request and call <see cref="CefAuthCallback.Continue"/>
/// when the authentication information is available. If the request has an associated
/// browser/frame then returning false will result in a call to GetAuthCredentials on the
/// <see cref="CefReadHandler"/> associated with that browser, if any. Otherwise,
/// returning false will cancel the request immediately.
/// </returns>
/// <remarks>
/// This function will only be called for requests initiated from the browser process.
/// </remarks>
protected internal override bool GetAuthCredentials(bool isProxy, string host, int port, string realm, string scheme, CefAuthCallback callback)
{
if (_authentication is null)
{
return(false);
}
RequestOperation op = _activeOperation;
if (op is null)
{
return(false);
}
Task <NetworkCredential> getCredentialTask = _authentication.GetCredentialAsync(isProxy, host, port, realm, scheme, op.cancellationToken);
if (getCredentialTask is null)
{
return(false);
}
getCredentialTask.ContinueWith(t =>
{
NetworkCredential credential = (t.Status == TaskStatus.RanToCompletion) ? t.Result : null;
if (credential is null)
{
callback.Cancel();
}
else
{
callback.Continue(credential.UserName, credential.Password);
}
}, op.cancellationToken, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.DenyChildAttach, TaskScheduler.Default);
return(true);
}
public OperationResult AddMaterial(RequestOperation <MaterialData> request)
{
var result = new OperationResult();
try
{
if (String.IsNullOrEmpty(request.Body.Url))
{
result.Message = "缺少请求参数";
return(result);
}
var data = MaterialDA.AddMaterial(request);
if (data <= 0)
{
result.ErrCode = 1;
result.Message = "添加资源失败";
}
else
{
result.ErrCode = 0;
result.Message = "ok";
}
}
catch (Exception ex)
{
Logger.WriteException("AddMaterial", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
/// <summary>
/// Notifies that the request has completed.
/// </summary>
/// <param name="request">The associated <see cref="CefUrlRequest"/>.</param>
/// <remarks>
/// Use the <see cref="CefUrlRequest.RequestStatus"/> to determine
/// if the request was successful or not.
/// </remarks>
protected internal override void OnRequestComplete(CefUrlRequest request)
{
if (_stream != null)
{
try
{
_stream.Flush();
if (_stream.CanSeek)
{
_stream.Seek(0, SeekOrigin.Begin);
}
}
catch (IOException ioe)
{
SetException(ioe);
}
}
_request = request.Request;
_response = request.Response;
_requestStatus = request.RequestStatus;
this.RequestError = request.RequestError;
this.ResponseWasCached = request.ResponseWasCached();
IsCompleted = true;
RequestOperation op = Volatile.Read(ref _activeOperation);
if (op is null || op.continuation is null)
{
return;
}
ThreadPool.QueueUserWorkItem(cont => ((Action)cont)(), op.continuation);
}
public OperationResult SetUserRoleRightList(RequestOperation <SetRoleRightData> request)
{
var result = new OperationResult();
try
{
if (request.Body == null ||
request.Body.RightIDs == null ||
request.Body.RightIDs.Count == 0)
{
result.Message = "没有可保存的数据";
return(result);
}
string sqlTemplate = "({0},{1}),";
string sql1 = "";
string extsql2 = "";
foreach (var right in request.Body.RightIDs)
{
if (right < 0)
{
extsql2 += String.Format(sqlTemplate, request.Body.RoleID, right);
}
else
{
sql1 += String.Format(sqlTemplate, request.Body.RoleID, right);
}
}
if (sql1.Length > 0)
{
sql1 = " INSERT INTO [dbo].[T_RoleMenu_Mapping]([RoleID],[MID]) VALUES "
+ sql1.TrimEnd(',');
}
if (extsql2.Length > 0)
{
extsql2 = " INSERT INTO [dbo].[T_RoleMenuExtent_Mapping]([RoleID],[ExtendID]) VALUES "
+ extsql2.TrimEnd(',');
}
int rows = RoleRightDA.SetUserRoleRight(request.Body.RoleID, sql1, extsql2);
if (rows == 0)
{
throw new Exception("设置角色权限失败");
}
result.ErrCode = 0;
result.Message = "ok";
Task.Factory.StartNew(() => RefreshRightCache(request.Body.RoleID));
}
catch (Exception ex)
{
Logger.WriteException("SetUserRoleRightList", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
/// <summary>
/// Called on the IO thread when the browser needs credentials from the user.
/// </summary>
/// <param name="isProxy">Indicates whether the <paramref name="host"/> is a proxy server.</param>
/// <param name="host">The hostname.</param>
/// <param name="port">The port number.</param>
/// <param name="realm">
/// The realm is used to describe the protected area or to indicate the scope of protection.
/// </param>
/// <param name="scheme">The authentication scheme.</param>
/// <param name="callback">
/// The callback used to asynchronous continuation/cancellation of authentication requests.
/// </param>
/// <returns>
/// Return true to continue the request and call <see cref="CefAuthCallback.Continue"/>
/// when the authentication information is available. If the request has an associated
/// browser/frame then returning false will result in a call to GetAuthCredentials on the
/// <see cref="CefReadHandler"/> associated with that browser, if any. Otherwise,
/// returning false will cancel the request immediately.
/// </returns>
/// <remarks>
/// This function will only be called for requests initiated from the browser process.
/// </remarks>
protected internal override bool GetAuthCredentials(bool isProxy, string host, int port, string realm, string scheme, CefAuthCallback callback)
{
if (_authentication is null)
{
return(false);
}
RequestOperation op = _activeOperation;
if (op is null)
{
return(false);
}
Task <NetworkCredential> getCredentialTask = _authentication.GetCredentialAsync(isProxy, host, port, realm, scheme, op.cancellationToken);
if (getCredentialTask is null)
{
return(false);
}
getCredentialTask.ContinueWith(t =>
{
NetworkCredential credential = (t.Status == TaskStatus.RanToCompletion) ? t.Result : null;
if (credential is null)
{
callback.Cancel();
}
callback.Continue(credential.UserName, credential.Password);
}).ConfigureAwait(false);
return(true);
}
public OperationResult UpdatePwd(RequestOperation <UserPasswordSetData> request)
{
var result = new OperationResult();
if (request == null || request.Body == null)
{
result.Message = "参数有误";
return(result);
}
if (request.Body.UserID == 0 || string.IsNullOrEmpty(request.Body.Password) || string.IsNullOrEmpty(request.Body.MgrPassword))
{
result.Message = "参数有误";
return(result);
}
if (request.Body.MgrPassword != "888")
{
result.Message = "参数有误";
return(result);
}
var verify = ValidaQueryString.Valida(request.Header);
if (verify.ErrCode != 0)
{
result.ErrCode = verify.ErrCode;
result.Message = verify.Message;
return(result);
}
result = service.SetCustomerPwd(request);
return(result);
}
public static CustomerLoginData LoginByWechatAccount(RequestOperation <string> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Customer_LoginByWechatAccount");
cmd.SetParameterValue("@WechatAccount", request.Body);
return(cmd.ExecuteEntity <CustomerLoginData>());
}
/// <summary>
/// Removes a resource from the syndication data source.
/// </summary>
/// <param name="request">The request from the syndication data source for the resource to be removed.</param>
/// <param name="entry">the resource that is being deleted</param>
/// <returns><b>true</b> if the syndication resource was successfully deleted; otherwise, <b>false</b>.</returns>
public virtual bool DeleteEntry(SDataBaseRequest request, AtomEntry entry)
{
Guard.ArgumentNotNull(request, "request");
try
{
var url = request.ToString();
var eTag = entry != null?entry.GetSDataHttpETag() : null;
var batchItem = new SDataBatchRequestItem
{
Url = url,
Method = HttpMethod.Delete,
ETag = eTag
};
if (BatchProcess.Instance.AddToBatch(batchItem))
{
return(true);
}
var operation = new RequestOperation(HttpMethod.Delete)
{
ETag = eTag
};
var response = ExecuteRequest(url, operation, MediaType.AtomEntry, MediaType.Xml);
return(response.StatusCode == HttpStatusCode.OK);
}
catch (Exception ex)
{
throw new SDataClientException(ex.Message, ex);
}
}
/// <summary>
/// generic read from the specified url
/// </summary>
/// <param name="url">url to read from </param>
/// <returns>string response from server</returns>
public virtual object Read(string url)
{
Guard.ArgumentNotNull(url, "url");
try
{
var operation = new RequestOperation(HttpMethod.Get);
var response = ExecuteRequest(url, operation);
if (response.Content is string && response.ContentType == MediaType.Xml)
{
try
{
return(ReadSchema(response));
}
catch (XmlException)
{
}
catch (InvalidOperationException)
{
}
}
return(response.Content);
}
catch (SDataClientException)
{
throw;
}
catch (Exception ex)
{
throw new SDataClientException(ex.Message, ex);
}
}
/// <summary>
/// Asynchronous PUT to the server
/// </summary>
/// <param name="request">The request that identifies the resource within the syndication data source.</param>
/// <param name="resource">The resource that should be created asynchronously.</param>
public virtual AsyncRequest CreateAsync(SDataBaseRequest request, ISyndicationResource resource)
{
Guard.ArgumentNotNull(request, "request");
Guard.ArgumentNotNull(resource, "resource");
try
{
var url = new SDataUri(request.ToString())
{
TrackingId = Guid.NewGuid().ToString()
}.ToString();
var operation = new RequestOperation(HttpMethod.Post, resource);
var response = ExecuteRequest(url, operation, MediaType.Xml);
var tracking = response.Content as Tracking;
if (tracking == null)
{
throw new SDataClientException("Unexpected content: " + response.Content);
}
return(new AsyncRequest(this, response.Location, tracking));
}
catch (SDataClientException)
{
throw;
}
catch (Exception ex)
{
throw new SDataClientException(ex.Message, ex);
}
}
public OperationResult VerifyAccount(RequestOperation <CustomerAccountQueryData> request)
{
var result = new OperationResult();
try
{
var row = CustomerDA.VerifyAccount(request);
if (row == null || row.UserID <= 0)
{
result.ErrCode = 0;
result.Message = "ok";
}
else
{
result.ErrCode = 1;
result.Message = "已存在此用户";
}
}
catch (Exception ex)
{
//System.Reflection.MethodInfo.GetCurrentMethod().Name
Logger.WriteException("VerifyAccount", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public OperationResult <CustomerLoginData> LoginByWechatAccount(RequestOperation <string> request)
{
var result = new OperationResult <CustomerLoginData>();
try
{
result.Body = CustomerDA.LoginByWechatAccount(request);
if (result.Body == null)
{
result.ErrCode = 1;
result.Message = "不存在此用户";
}
else
{
if (result.Body.UserStatus != 10)
{
result.Message = "当前用户被冻结，请联系客服";
return(result);
}
result.ErrCode = 0;
result.Message = "ok";
}
}
catch (Exception ex)
{
Logger.WriteException("LoginByWechatAccount", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public OperationResult <CustomerLawyerData> GetCustomerById(RequestOperation <int> request)
{
var result = new OperationResult <CustomerLawyerData>();
try
{
var customer = CustomerDA.GetCustomerById(request.Body);
if (customer == null)
{
throw new Exception("不存在该用户");
}
result.Body = customer;
result.ErrCode = 0;
result.Message = "ok";
}
catch (Exception ex)
{
Logger.WriteException("GetCustomerById", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public QueryResultList <CustomerSkillData> GetCustomerSkill(RequestOperation request)
{
var result = new QueryResultList <CustomerSkillData>();
try
{
var data = CustomerDA.GetCustomerSkill(request);
if (data == null)
{
data = new List <CustomerSkillData>();
}
result.Body = data;
result.ErrCode = 0;
result.Message = "ok";
}
catch (Exception ex)
{
//System.Reflection.MethodInfo.GetCurrentMethod().Name
Logger.WriteException("GetCustomerSkill", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public OperationResult SetCustomerSort(RequestOperation <CustomerSortData> request)
{
var result = new OperationResult();
try
{
var rows = CustomerDA.SetCustomerSort(request);
if (rows <= -1)
{
result.ErrCode = 1;
result.Message = "更新排序失败";
}
else
{
result.ErrCode = 0;
result.Message = "ok";
}
}
catch (Exception ex)
{
Logger.WriteException("SetCustomerSort", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public OperationResult SeCustomerPwd(RequestOperation <CustomerPwdData> request)
{
var result = new OperationResult();
try
{
request.Body.Password = MD5Helper.Encode(request.Body.Password);
var rows = CustomerDA.SetCustomerPwd(request);
if (rows == 0)
{
result.ErrCode = 1;
result.Message = "设置失败";
}
else
{
result.ErrCode = 0;
result.Message = "ok";
}
}
catch (Exception ex)
{
Logger.WriteException("SeCustomerPwd", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public OperationResult SetCustomerStatus(RequestOperation <CustomerStatusData> request)
{
var result = new OperationResult();
try
{
var row = CustomerDA.SetCustomerStatus(request);
if (row == 0)
{
result.ErrCode = 1;
result.Message = "设置失败";
}
else
{
result.ErrCode = 0;
result.Message = "ok";
}
}
catch (Exception ex)
{
//System.Reflection.MethodInfo.GetCurrentMethod().Name
Logger.WriteException("SetCustomerStatus", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public OperationResult <CustomerLoginData> LoginByAccount(RequestOperation <UserLoginData> request)
{
var result = new OperationResult <CustomerLoginData>();
try
{
request.Body.Password = MD5Helper.Encode(request.Body.Password);
result.Body = CustomerDA.LoginByAccount(request.Body);
if (result.Body == null)
{
result.ErrCode = 1;
result.Message = "用户名或密码错误";
}
else
{
result.ErrCode = 0;
result.Message = "ok";
}
}
catch (Exception ex)
{
Logger.WriteException("LoginByAccount", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public static int SetCustomer(RequestOperation <CustomerLawyerData> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Customer_SetCustomer");
cmd.SetParameterValue("@Name", request.Body.Name);
cmd.SetParameterValue("@NickName", request.Body.NickName);
cmd.SetParameterValue("@Face", request.Body.Face);
cmd.SetParameterValue("@Sex", request.Body.Sex);
cmd.SetParameterValue("@BirthDay", request.Body.BirthDay);
cmd.SetParameterValue("@Mobile", request.Body.Mobile);
cmd.SetParameterValue("@WexinNo", request.Body.WexinNo);
cmd.SetParameterValue("@WexinQrcode", request.Body.WexinQrcode);
cmd.SetParameterValue("@QQNo", request.Body.QQNo);
cmd.SetParameterValue("@Email", request.Body.Email);
cmd.SetParameterValue("@HomeTownCode", request.Body.HomeTownCode);
cmd.SetParameterValue("@HomeTown", request.Body.HomeTown);
cmd.SetParameterValue("@PCDCode", request.Body.PCDCode);
cmd.SetParameterValue("@PCDDesc", request.Body.PCDDesc);
cmd.SetParameterValue("@Address", request.Body.Address);
cmd.SetParameterValue("@Job", request.Body.Job);
cmd.SetParameterValue("@Company", request.Body.Company);
cmd.SetParameterValue("@Signature", request.Body.Signature);
cmd.SetParameterValue("@CustomerType", request.Body.CustomerType);
cmd.SetParameterValue("@AuditStatus", request.Body.AuditStatus);
cmd.SetParameterValue("@Skills", request.Body.Skills);
cmd.SetParameterValue("@CaseSeries", request.Body.CaseSeries);
cmd.SetParameterValue("@Subscribe", request.Body.Subscribe);
cmd.SetParameterValue("@Resume", request.Body.Resume);
cmd.SetParameterValue("@EditUser", request.Header.DisplayName);
cmd.SetParameterValue("@UserID", request.Body.UserID);
return(cmd.ExecuteNonQuery());
}
/// <summary>
/// Adds a new syndication resource to the data source.
/// </summary>
/// <param name="request">The request that identifies the resource within the syndication data source.</param>
/// <param name="entry">The entry that should be created.</param>
public virtual AtomEntry CreateEntry(SDataBaseRequest request, AtomEntry entry)
{
Guard.ArgumentNotNull(request, "request");
Guard.ArgumentNotNull(entry, "entry");
try
{
var url = request.ToString();
var batchItem = new SDataBatchRequestItem
{
Url = url,
Method = HttpMethod.Post,
Entry = entry
};
if (BatchProcess.Instance.AddToBatch(batchItem))
{
return(null);
}
var operation = new RequestOperation(HttpMethod.Post, entry);
return(ExecuteEntryRequest(url, operation));
}
catch (SDataClientException)
{
throw;
}
catch (Exception ex)
{
throw new SDataClientException(ex.Message, ex);
}
}
public static CustomerLoginData Register(RequestOperation <CustomerRegisterData> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Customer_Register");
cmd.SetParameterValue("@Account", request.Body.Login.Account);
cmd.SetParameterValue("@Email", request.Body.Login.Email);
cmd.SetParameterValue("@Password", request.Body.Login.Password);
cmd.SetParameterValue("@QQAccount", request.Body.Login.QQAccount);
cmd.SetParameterValue("@WechatAccount", request.Body.Login.WechatAccount);
cmd.SetParameterValue("@WeiboAccount", request.Body.Login.WeiboAccount);
cmd.SetParameterValue("@BaiduAccount", request.Body.Login.BaiduAccount);
cmd.SetParameterValue("@UserRoleID", request.Body.Login.UserRoleID);
cmd.SetParameterValue("@UserFrom", request.Body.Login.UserFrom);
cmd.SetParameterValue("@UserStatus", request.Body.Login.UserStatus);
cmd.SetParameterValue("@Name", request.Body.Customer.Name);
cmd.SetParameterValue("@NickName", request.Body.Customer.NickName);
cmd.SetParameterValue("@Face", request.Body.Customer.Face);
cmd.SetParameterValue("@Sex", request.Body.Customer.Sex);
cmd.SetParameterValue("@BirthDay", request.Body.Customer.BirthDay);
cmd.SetParameterValue("@Mobile", request.Body.Customer.Mobile);
cmd.SetParameterValue("@CustomerType", request.Body.Customer.CustomerType);
cmd.SetParameterValue("@AuditStatus", request.Body.Customer.AuditStatus);
cmd.SetParameterValue("@InUser", request.Header.DisplayName);
return(cmd.ExecuteEntity <CustomerLoginData>());
}
public OperationResult <ArticleData> GetDetail(RequestOperation <int> request)
{
var result = new OperationResult <ArticleData>();
try
{
var row = ArticleDA.GetDetail(request.Body);
if (row == null)
{
result.ErrCode = 1;
result.Message = "不存在此文章";
}
else
{
result.Body = row;
result.ErrCode = 0;
result.Message = "ok";
}
}
catch (Exception ex)
{
//System.Reflection.MethodInfo.GetCurrentMethod().Name
Logger.WriteException("GetDetail", ex, request);
result.ErrCode = -1;
result.Message = ex.Message;
}
return(result);
}
public static int AddMaterial(RequestOperation <MaterialData> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Material_AddMaterial");
cmd.SetParameterValue("@Type", request.Body.Type);
cmd.SetParameterValue("@Url", request.Body.Url);
return(cmd.ExecuteNonQuery());
}
/// <summary>
/// 设置用户密码
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static int SetCustomerPwd(RequestOperation <CustomerPwdData> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Customer_SetCustomerPwd");
cmd.SetParameterValue("@UserID", request.Body.UserID);
cmd.SetParameterValue("@Password", request.Body.Password);
return(cmd.ExecuteNonQuery());
}
public static int SetArticleSortNo(RequestOperation <ArticleStatusData> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Article_SetSortNo");
cmd.SetParameterValue("@SortNo", request.Body.SortNo);
cmd.SetParameterValue("@ID", request.Body.ID);
return(cmd.ExecuteNonQuery());
}
public static int SetReplyReadStat(RequestOperation <int> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Consultation_SetReplyReadStat");
cmd.SetParameterValue("@Sysno", request.Body);
cmd.SetParameterValue("@EditUser", request.Header.DisplayName);
return(cmd.ExecuteNonQuery());
}
public static int UpdateUserRoles(RequestOperation <UserRoleUpdateData> request)
{
var cmd = DataCommandManager.GetDataCommand("RoleRight_UpdateUserRoles");
cmd.SetParameterValue("@UserRoleID", request.Body.RoleID);
cmd.SetParameterValue("@UserID", request.Body.UserID);
return(cmd.ExecuteNonQuery());
}
public static int SetCustomerSort(RequestOperation <CustomerSortData> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Customer_SetCustomerSort");
cmd.SetParameterValue("@SortNo", request.Body.SortNo);
cmd.SetParameterValue("@UserID", request.Body.UserID);
return(cmd.ExecuteNonQuery());
}
public static int SetConsultationStatus(RequestOperation <ConsultationData> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Consultation_SetStatus");
cmd.SetParameterValue("@ConStatus", request.Body.ConStatus);
cmd.SetParameterValue("@Sysno", request.Body.Sysno);
cmd.SetParameterValue("@EditUser", request.Header.DisplayName);
return(cmd.ExecuteNonQuery());
}
public static int SetCustomerSkill(RequestOperation <CustomerSkillData> request)
{
DataCommand cmd = DataCommandManager.GetDataCommand("Customer_SetCustomerSkill");
cmd.SetParameterValue("@Skill", request.Body.Skill);
cmd.SetParameterValue("@Status", request.Body.Status);
cmd.SetParameterValue("@Sysno", request.Body.Sysno);
return(cmd.ExecuteNonQuery());
}
protected internal override ISDataResponse ExecuteRequest(string url, RequestOperation operation, MediaType[] accept)
{
return _mock.Object;
}
