public void ExecuteAsSession()
{
var tx = new WeaverTransaction();
var q = new WeaverQuery();
q.FinalizeQuery("'zach'");
tx.AddQuery(q);
q = new WeaverQuery();
q.FinalizeQuery("x = 10+2;");
tx.AddQuery(q);
q = new WeaverQuery();
q.FinalizeQuery("x*x");
tx.AddQuery(q);
tx.Finish();
IResponseResult result = tx.ExecuteAsSession(RexConnHost, RexConnPort, "1234");
CheckResult(result, "1234", 3 + 3, 1); //include session start/commit/close
Assert.AreEqual("zach", result.GetTextResultsAt(1).ToString(0), "Incorrect 1,0 result value.");
Assert.AreEqual(12, result.GetTextResultsAt(2).ToInt(0), "Incorrect 2,0 result value.");
Assert.AreEqual(144, result.GetTextResultsAt(3).ToInt(0), "Incorrect 3,0 result value.");
}
public virtual async Task <IResponseResult> AddAsync(TDto model)
{
try
{
PropertyInfo propertyInfo = model.GetType().GetProperty("Id");
if (propertyInfo.PropertyType == typeof(string))
{
propertyInfo.SetValue(model, Convert.ChangeType(Guid.NewGuid().ToString(), propertyInfo.PropertyType), null);
}
T entity = Mapper.Map <TDto, T>(model);
_unitOfWork.Repository.Add(entity);
int affectedRows = await _unitOfWork.SaveChanges();
if (affectedRows > 0)
{
result = new ResponseResult(result: null, status: HttpStatusCode.Created, message: "Data Inserted Successfully");
}
result.Data = model;
return(result);
}
catch (Exception e)
{
result.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
result = new ResponseResult(null, HttpStatusCode.InternalServerError, e, result.Message);
return(result);
}
}
public DataPagging(int pageNumber, int pageSize, int totalPage, IResponseResult result)
{
PageNumber = pageNumber;
PageSize = pageSize;
TotalPage = totalPage;
Result = result;
}
public void ExecuteQuery()
{
var q = new WeaverQuery();
q.FinalizeQuery("g");
IResponseResult result = q.Execute(RexConnHost, RexConnPort, "1234");
CheckResult(result, "1234", 1, 1);
}
public void ExecuteRequest()
{
var r = new WeaverRequest("1234");
r.AddQuery("g");
IResponseResult result = r.Execute(RexConnHost, RexConnPort);
CheckResult(result, "1234", 1, 1);
}
public IResult GetResult(IResponseResult responseResult)
{
_result.Status = responseResult.Status;
_result.Message = responseResult.Message;
if (!HasError(responseResult.Exception))
{
_result.Data = responseResult.Data;
}
return(_result);
}
public ServiceBaseParameter(
IMapper mapper,
IUnitOfWork <T, TKey> unitOfWork,
IResponseResult responseResult,
IHttpContextAccessor httpContextAccessor
)
{
Mapper = mapper;
UnitOfWork = unitOfWork;
ResponseResult = responseResult;
HttpContextAccessor = httpContextAccessor;
}
protected internal BaseService(IServiceBaseParameter <T, TKey> businessBaseParameter)
{
HttpContextAccessor = businessBaseParameter.HttpContextAccessor;
UnitOfWork = businessBaseParameter.UnitOfWork;
ResponseResult = businessBaseParameter.ResponseResult;
Mapper = businessBaseParameter.Mapper;
var claims = HttpContextAccessor.HttpContext.User;
ClaimData = new TokenClaimDto()
{
UserId = claims?.FindFirst(t => t.Type == "UserId")?.Value,
Email = claims?.FindFirst(t => t.Type == "Email")?.Value
};
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void CheckResult(IResponseResult pResult, string pReqId, int pCmdCount, int pCmd0Results)
{
Assert.NotNull(pResult, "Result should be filled.");
Assert.NotNull(pResult.Response, "Response should be filled.");
Assert.NotNull(pResult.ResponseJson, "ResponseJson should be filled.");
Assert.AreEqual(pReqId, pResult.Response.ReqId, "Incorrect Response.ReqId.");
Assert.NotNull(pResult.Response.CmdList, "Response.CmdList should be filled.");
Assert.AreEqual(pCmdCount, pResult.Response.CmdList.Count, "Incorrect Response.CmdList.Count.");
Assert.NotNull(pResult.Response.CmdList[0].Results,
"Response.CmdList[0].Results should be filled.");
Assert.AreEqual(pCmd0Results, pResult.Response.CmdList[0].Results.Count,
"Incorrect Response.CmdList[0].Results.Count.");
}
private static IResponseResult <BearerToken> ConvertToBearerTokenResponse(IResponseResult response)
{
if (response.IsSuccess)
{
var bearerToken = BearerToken.ParseFromJson(response.Json);
if (response.StatusCode == null)
{
return(new ResponseResult <BearerToken>(response.IsSuccess, response.Message)
{
Data = bearerToken,
Json = response.Json,
RawData = response.RawData,
Exception = response.Exception
});
}
else
{
return(new ResponseResult <BearerToken>(response.StatusCode.Value, response.Message)
{
Data = bearerToken,
Json = response.Json,
RawData = response.RawData,
Exception = response.Exception
});
}
}
else
{
if (response.StatusCode == null)
{
return(new ResponseResult <BearerToken>(response.IsSuccess, response.Message)
{
Json = response.Json,
RawData = response.RawData,
Exception = response.Exception
});
}
else
{
return(new ResponseResult <BearerToken>(response.StatusCode.Value, response.Message)
{
Json = response.Json,
RawData = response.RawData,
Exception = response.Exception
});
}
}
}
public virtual async Task <IResponseResult> GetAllAsync()
{
try
{
var query = await _unitOfWork.Repository.GetAllAsync();
var data = Mapper.Map <IEnumerable <T>, IEnumerable <TDto> >(query);
return(ResponseResult.GetRepositoryActionResult(data, status: HttpStatusCode.OK, message: HttpStatusCode.OK.ToString()));
}
catch (Exception e)
{
result.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
result = new ResponseResult(null, status: HttpStatusCode.InternalServerError, exception: e, message: result.Message);
return(result);
}
}
public virtual async Task <IResponseResult> GetByIdAsync(object id)
{
try
{
T query = await _unitOfWork.Repository.GetAsync(id);
var data = Mapper.Map <T, TDto>(query);
return(ResponseResult.GetRepositoryActionResult(result: data, status: HttpStatusCode.OK, message: "Data Updated Successfully"));
}
catch (Exception e)
{
result.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
result = new ResponseResult(null, HttpStatusCode.InternalServerError, e, result.Message);
return(result);
}
}
/*--------------------------------------------------------------------------------------------*/
private void LogAction(IResponseResult pRes)
{
//DBv1:
// TotalMs, QueryMs, Timestamp, QueryChars, ExecuteName
const string name = "DBv1";
const string x = " | ";
string v1 =
pRes.ExecutionMilliseconds + x +
pRes.Response.Timer + x +
DateTime.UtcNow.Ticks + x +
pRes.RequestJson.Length + x +
ExecuteName;
vLogOutput(this, name, v1);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public IDataResult Execute(string pName)
{
ExecuteName = pName;
var data = new RexConnDataAccess(vRexConnCtx);
IResponseResult rr = null;
if (vPreExecute != null)
{
vPreExecute(this, data);
}
try {
rr = data.Execute();
}
catch (ResponseErrException ree) {
if (vPostExecuteErr != null)
{
vPostExecuteErr(this, ree);
}
throw new DataAccessException(this, ree.Message);
}
catch (Exception e) {
if (vPostExecuteErr != null)
{
vPostExecuteErr(this, e);
}
throw;
}
if (vPostExecute != null)
{
vPostExecute(this, rr);
}
LogAction(rr);
return(new DataResult(rr));
}
/*--------------------------------------------------------------------------------------------*/
protected virtual void OnDataPostExecute(IDataAccess pAccess, IResponseResult pResult)
{
DbQueryExecutionCount++;
DbQueryMillis += (pResult.Response.Timer == null ? 0 : (int)pResult.Response.Timer);
string key = "opdata." + pAccess.ExecuteName;
vMetrics.Counter(key, 1);
if (pResult.Response.Timer != null)
{
vMetrics.Timer(key + ".rc", (long)pResult.Response.Timer);
}
vMetrics.Timer(key + ".ex", (long)pResult.ExecutionMilliseconds);
vMetrics.Mean(key + ".len", pResult.ResponseJson.Length);
vMetrics.Counter(key + ".err", (pResult.IsError ? 1 : 0));
//Log.Debug(ContextId, "Data", "PostExec timer: "+pResult.Response.Timer+"ms");
//Log.Debug(ContextId.ToString("N"), "Data", "Request: "+pResult.RequestJson);
//Log.Debug(ContextId.ToString("N"), "Data", "Response: "+pResult.ResponseJson);
}
public virtual async Task <IResponseResult> DeleteAsync(object id)
{
try
{
var entityToDelete = await _unitOfWork.Repository.GetAsync(id);
_unitOfWork.Repository.Remove(entityToDelete);
int affectedRows = await _unitOfWork.SaveChanges();
if (affectedRows > 0)
{
result = ResponseResult.GetRepositoryActionResult(result: true, status: HttpStatusCode.Accepted, message: "Data Updated Successfully");
}
return(result);
}
catch (Exception e)
{
result.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
result = new ResponseResult(null, HttpStatusCode.InternalServerError, e, result.Message);
return(result);
}
}
public void ExecuteTx()
{
var tx = new WeaverTransaction();
var q = new WeaverQuery();
q.FinalizeQuery("g");
tx.AddQuery(q);
q = new WeaverQuery();
q.FinalizeQuery("x = 10+2");
tx.AddQuery(q);
q = new WeaverQuery();
q.FinalizeQuery("x*x");
tx.AddQuery(q);
tx.Finish();
IResponseResult result = tx.Execute(RexConnHost, RexConnPort, "1234");
CheckResult(result, "1234", 1, 1);
Assert.AreEqual(144, result.GetTextResultsAt(0).ToInt(0), "Incorrect result value.");
}
public virtual async Task <IResponseResult> UpdateAsync(TDto model)
{
try
{
var id = Helper.GetPropValue(model, "Id");
T entityToUpdate = await _unitOfWork.Repository.GetAsync(id);
Mapper.Map(model, entityToUpdate);
int affectedRows = await _unitOfWork.SaveChanges();
if (affectedRows > 0)
{
result = ResponseResult.GetRepositoryActionResult(result: true, status: HttpStatusCode.Accepted, message: "Data Updated Successfully");
}
return(result);
}
catch (Exception e)
{
result.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
result = new ResponseResult(null, HttpStatusCode.InternalServerError, e, result.Message);
return(result);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public DataResult(IResponseResult pResult)
{
vResult = pResult;
}
static string FormatResponse(IResponseResult result) =>
result switch
{
public ServiceBaseParameter(IMapper mapper, IUnitOfWork <T> unitOfWork, IResponseResult responseResult)
{
Mapper = mapper;
UnitOfWork = unitOfWork;
ResponseResult = responseResult;
}
protected internal BaseService(IServiceBaseParameter <T> businessBaseParameter)
{
UnitOfWork = businessBaseParameter.UnitOfWork;
ResponseResult = businessBaseParameter.ResponseResult;
Mapper = businessBaseParameter.Mapper;
}
