public string Call(string exchange, string routingKey, TRequest request)
{
var respQueue = new BlockingCollection <string>();
string queueName = _channel.QueueDeclare().QueueName;
_props = _channel.CreateBasicProperties();
var correlationId = Guid.NewGuid().ToString();
_props.CorrelationId = correlationId;
_props.ReplyTo = queueName;
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (model, ea) =>
{
if (ea.BasicProperties.CorrelationId == correlationId)
{
respQueue.Add(Encoding.UTF8.GetString(ea.Body.ToArray()));
_channel.BasicAck(ea.DeliveryTag, false);
}
};
string requestString = JsonConvert.SerializeObject(request);
byte[] messageBytes = Encoding.UTF8.GetBytes(requestString);
_channel.BasicConsume(queue: queueName, autoAck: false, consumer: consumer);
_channel.BasicPublish(exchange: exchange, routingKey: routingKey, basicProperties: _props, body: messageBytes);
return(respQueue.Take());
}
public ResponseAsyncEnumerator(CallSettings callSettings,
TRequest request, ApiCall <TRequest, TResponse> apiCall)
{
_callSettings = callSettings;
_request = request;
_apiCall = apiCall;
}
/// <summary>
/// Check source name from current query.
/// </summary>
/// <returns>True - source exists, False - error.</returns>
public Boolean CheckSource()
{
var errMessage = "";
if (this.context.Request.Contains("source"))
{
var source = this.context.Request["source"];
if (BLANK(source))
{
errMessage += "Empty source name!<br/>";
}
else if (!TRequest.IsDomainName("source"))
{
errMessage += "Incorrect source name!<br/>";
}
}
if (errMessage.Length == 0)
{
return(true);
}
var prepare = new THashtable();
prepare["[#ErrMessage]"] = errMessage;
this.Write("error", prepare);
return(false);
}
/// Execute main logic for DoRedirectItem action
public override void Execute()
{
var errorMessage = (String)null;
var linkToRedirect = (String)null;
if (!this.context.Request.Contains("id"))
{
errorMessage = "Item ID is required!";
}
else
{
var id = this.context.Request["id"];
if (!TRequest.IsInteger(id) || INT(id) <= 0)
{
errorMessage = "Incorrect item ID!";
}
else
{
var doItem = new DOItem(this.context.Connection);
var dsItems = doItem.GetById(INT(id));
if (dsItems.GetSize() == 0)
{
errorMessage = "No item with such ID!";
}
else
{
var oItem = dsItems.GetRow(0);
linkToRedirect = STR(oItem["s_Link"]);
}
}
}
this.ExecuteRedirect(linkToRedirect, errorMessage);
}
public async Task <IActionResult> UserLogin(TRequest <UserLoginRequest> request)
{
if (request == null)
{
return(NotFound());
}
var response = new Response <UserLoginResponse>();
try
{
request.value.Password = request.value.Password.AsMd5();
var data = await _userService.GetByUserName(request.value.UserName);
if (data == null)
{
response.Success = false;
response.Message = "Tên đăng nhập không tồn tại";
return(Ok(response));
}
if (data.Password != request.value.Password)
{
response.Success = false;
response.Message = "Mật khẩu không đúng";
return(Ok(response));
}
if (data.Deleted.Value)
{
response.Success = false;
response.Message = "Tài khoản đã bị xóa";
return(Ok(response));
}
if (data.Status != 1)
{
response.Success = false;
response.Message = "Tài khoản đã bị khóa";
return(Ok(response));
}
HttpContext.Session.SetObjectAsJson("User", data);
var deparmentId = HttpContext.Session.GetObjectFromJson <User>("User");
var currentDateTime = DateTime.Now;
var input = $"{data.Id};{data.UserName};{data.IsRoot};{currentDateTime};";
var accessToken = input.AsSha256();
var permission = await _functionService.GetActionByUserId(data.Id);
response.Data = new UserLoginResponse
{
User = data,
AccessToken = accessToken,
rights = permission.Select(c => c.Code).ToList()
};
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message + "," + ex.InnerException;
}
return(Ok(response));
}
public async Task <bool> Can <TRequest>() where TRequest : new()
{
var request = new TRequest();
var result = await _rules.Evaluate(request, FeatureInfo.For(request));
return(result.IsAuthorized);
}
void AddRequest(TClient c, string cmdLine)
{
var r = new TRequest(c, ctrl, cmdLine);
if (!r.Finished) // parsed succesfully?
{
pendingRequests.Add(r);
}
}
public dynamic ImageToDir(TRequest json)
{
Dictionary <string, dynamic> defultdr = new Dictionary <string, dynamic>();
if (json.dict != null)
{
// defultdr = json.dict;//deserializeToDictionary(json.dict);
foreach (var item in json.dict)
{
defultdr.Add(item.Key, item.Value);
}
}
try
{
// Convert Base64 String to byte[]
byte[] imageBytes = Convert.FromBase64String(defultdr["@imageString"]);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
// Convert byte[] to Image
ms.Write(imageBytes, 0, imageBytes.Length);
Image image = Image.FromStream(ms, true);
image.Save(ImageDirPath + defultdr["@imageName"]);
//saving data to database
string emp_id_mine = defultdr["@emp_id_mine"];
string emp_id_other = defultdr["@emp_id_other"];
Dictionary <string, dynamic> dict_param = new Dictionary <string, dynamic>();
dict_param.Add("@Message", defultdr["@imageName"]);
dict_param.Add("@mFrom", Int32.Parse(emp_id_mine));
dict_param.Add("@mTo", Int32.Parse(emp_id_other));
dict_param.Add("@isImage", 1);
try
{
Models.DAL.GetDataTableFromStoredProc("usp_m_chatMessage_Insert", dict_param, DBName.SCM);
//DAL.GetDataTable("usp_m_chatMessage_Insert", dict_param, System.Configuration.ConfigurationManager.ConnectionStrings["SCM"].ConnectionString);
}
catch (SqlException e)
{
Console.WriteLine(e.Message);
throw;
}
Dictionary <string, string> retDict = new Dictionary <string, string>();
retDict.Add("result", "Save Successful...");
return(Request.CreateResponse <Dictionary <string, string> >(HttpStatusCode.OK, retDict));
}
catch (Exception e)
{
Dictionary <string, string> retDict = new Dictionary <string, string>();
retDict.Add("result", e.Message);
return(Request.CreateResponse <Dictionary <string, string> >(HttpStatusCode.OK, retDict));
}
}
public ResponseAsyncEnumerator(CallSettings callSettings,
TRequest request, ApiCall <TRequest, TResponse> apiCall,
CancellationToken cancellationToken)
{
_callSettings = callSettings;
_request = request;
_apiCall = apiCall;
_cancellationToken = cancellationToken;
}
public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse
(
TRequest request,
ClientInterceptorContext<TRequest, TResponse> context,
AsyncUnaryCallContinuation<TRequest, TResponse> continuation
)
{
return base.AsyncUnaryCall(request, context, continuation);
}
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next)
{
_output.Messages.Add("ConstructorTestBehavior before");
var response = await next();
_output.Messages.Add("ConstructorTestBehavior after");
return(response);
}
public Task <TResponse> Process(TRequest request, ServiceFactory serviceFactory,
CancellationToken cancellationToken)
{
_behaviours = serviceFactory.GetInstances <IPipelineBehavior <TRequest, TResponse> >().GetEnumerator();
_cancellationToken = cancellationToken;
_request = request;
_serviceFactory = serviceFactory;
return(Next());
}
public async Task <TResponse> Execute(TRequest req)
{
LoggerHelper.Write(string.Format("Params: req=[ {0} ]", req?.ToString()));
var srv = ServiceProvider.Instance.Get <ISampleService>();
var res = await srv.GetDog(req);
return(res);
}
/// <summary>
/// Mapping properties from request object to BaseRequest
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <returns></returns>
public TRequest ToRequest <TRequest>()
where TRequest : BaseRequest, new()
{
var request = new TRequest()
{
ValidationId = ValidationId
};
return(request);
}
/// <summary>
/// Create a new generic response.
/// </summary>
/// <param name="Request">The request leading to this result.</param>
public ResponseBase(TRequest request) : base()
{
Request = request;
if (request != null)
{
Duration = ResponseTimestamp - request.RequestTimestamp;
MessageId = request.MessageId;
Name = request.GetType().Name.Replace("Request", "");
}
}
public Task <TResponse> UpdateSetting(TRequest request)
{
LoggerHelper.Write();
return(Task.Run(() =>
{
var key = ((object)request.Body.Key).ToString();
var value = ((object)request.Body.Value).ToString();
if (string.IsNullOrEmpty(request.Body.AccountName))
{
var items = _dbc.Table <Setting>().Where(m => m.AccountId == 0 && m.Key == key);
if (items.Count() > 0)
{
var one = items.First();
one.Value = value;
_dbc.Update(one);
}
}
else
{
var name = ((object)request.Body.AccountName).ToString();
var accts = _dbc.Table <Account>().Where(m => m.Name == name);
if (accts.Count() > 0)
{
var acct = accts.First();
var items = _dbc.Table <Setting>().Where(m => m.AccountId == acct.Id && m.Key == key);
if (items.Count() > 0)
{
var one = items.First();
one.Value = value;
_dbc.Update(one);
}
else
{
_dbc.Insert(new Setting()
{
AccountId = acct.Id,
Key = key,
Value = value,
});
}
}
}
return new TResponse()
{
Code = Status.OK
};
}));
}
public static ICommandHandler CreateFor <TRequest>() where TRequest : ICommandLineRequest, new()
{
return(CommandHandler.Create(
async(IHost host, ParseResult parseResult, CancellationToken cancellationToken) =>
{
var mediator = host.Services.GetRequiredService <IMediator>();
var request = new TRequest();
request.Map(parseResult);
await mediator.Send(request, cancellationToken);
}));
}
public IAsyncEnumerable <TResponse> Handle(
TRequest request,
CancellationToken cancellationToken,
StreamHandlerDelegate <TResponse> next)
{
_output.Messages.Add("StreamConstructorTestBehavior before");
#pragma warning disable CC0031 // Check for null before calling a delegate
return(next());
#pragma warning restore CC0031 // Check for null before calling a delegate
}
public static TResponse Execute(
string metodo, TRequest request, IConfiguracion config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
string y = config.apiUrl; //i need it
return(xxx); //xxxxx
}
public void Publish(string exchange, string routingKey, TRequest request)
{
string requestString = JsonConvert.SerializeObject(request);
byte[] messageBytes = Encoding.UTF8.GetBytes(requestString);
_channel.BasicPublish(
exchange: exchange,
routingKey: routingKey,
basicProperties: null,
body: messageBytes);
}
public TRequest CreateRequest <TRequest>()
where TRequest : JsonWebRequest, new()
{
var request = new TRequest
{
SessionManager = _sessionManager,
RootUri = _baseUri,
Logger = _logger,
};
request.RegisterConverters(_converters);
return(request);
}
public virtual async Task <(TModel, object[])> Handle(TRequest request, CancellationToken token)
{
var entity = Mapper.Map <TEntity>(request.Model);
var entityEntry = Context.Entry(entity);
entityEntry.State = EntityState.Added;
await Context.SaveChangesAsync(token).ConfigureAwait(false);
return(Mapper.Map <TModel>(entity), entityEntry.Metadata
.FindPrimaryKey()
.Properties
.Select(x => entityEntry.Property(x.Name).CurrentValue)
.ToArray());
}
public dynamic GetDataSql(TRequest json)
{
try
{
System.Data.DataTable dt = Models.DAL.GetDataTable(json.sp, json.db);
return(Request.CreateResponse <TResult>(HttpStatusCode.OK, new TResult(dt)));
}
catch (Exception e)
{
Dictionary <string, string> retDict = new Dictionary <string, string>();
retDict.Add("result", e.Message);
return(Request.CreateResponse <Dictionary <string, string> >(HttpStatusCode.OK, retDict));
}
}
public IActionResult AddEditActionOfUser(TRequest <ActionOfUserAddRequest> request)
{
var response = new Response <object>();
try
{
response.Success = _userService.AddEditActionOfUser(request.value) >= 0;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message + "," + ex.InnerException;
}
return(Ok(response));
}
/// <summary>
/// Create a new generic response.
/// </summary>
/// <param name="Request">The request leading to this result.</param>
/// <param name="ResponseTimestamp">The timestamp of the response creation.</param>
/// <param name="EventTrackingId">An optional event tracking identification for correlating this response with other events.</param>
/// <param name="Runtime">The runtime of the request/response.</param>
/// <param name="HTTPResponse">The optional HTTP response.</param>
/// <param name="ProcessId">The optional Hubject process identification of the request.</param>
/// <param name="CustomData">Optional customer-specific data of the response.</param>
protected Builder(TRequest Request = null,
DateTime?ResponseTimestamp = null,
EventTracking_Id EventTrackingId = null,
TimeSpan?Runtime = null,
HTTPResponse HTTPResponse = null,
Process_Id?ProcessId = null,
JObject CustomData = null)
{
this.Request = Request;
this.ResponseTimestamp = ResponseTimestamp;
this.EventTrackingId = EventTrackingId;
this.Runtime = Runtime;
this.HTTPResponse = HTTPResponse;
this.ProcessId = ProcessId;
this.CustomData = CustomData;
}
/// <summary>
/// Extracts the value from the request by matching it against the pattern,
/// returning the the key/value pair in the form key=value, after URI-escaping the value.
/// </summary>
public string ExtractKeyValuePair(TRequest request)
{
var match = _regex.Match(_selector(request) ?? "");
if (!match.Success)
{
return(null);
}
string value = match.Groups[1].Value;
if (value.Length == 0)
{
return(null);
}
return($"{ParameterName}={Uri.EscapeDataString(value)}");
}
IMapper <TViewModel, TRequest, TResponse> IMapperFactory.CreateMapper <TViewModel, TRequest, TResponse>()
{
Type[] typeList = GetTypesInNamespace(Assembly.GetExecutingAssembly(), "WeatherApp.ServiceLayerInteractions.Mappers");
for (int i = 0; i < typeList.Length; i++)
{
if (typeof(IMapper <TViewModel, TRequest, TResponse>).IsAssignableFrom(typeList[i]))
{
return(CreateMapper <TViewModel, TRequest, TResponse>(typeList[i]));
}
}
TRequest req = Activator.CreateInstance <TRequest>();
TResponse res = Activator.CreateInstance <TResponse>();
TViewModel vm = Activator.CreateInstance <TViewModel>();
throw new Exception("mapper not found by MapperFactory for request type: " + req.GetType());
}
public dynamic GetImageFromDir(TRequest json)
{
Dictionary <string, dynamic> defultdr = new Dictionary <string, dynamic>();
if (json.dict != null)
{
foreach (var item in json.dict)
{
defultdr.Add(item.Key, item.Value);
}
}
string filepath = ImageDirPath + defultdr["@fileName"];
byte[] imageArray = System.IO.File.ReadAllBytes(filepath);
return(Request.CreateResponse <byte[]>(HttpStatusCode.OK, imageArray));
}
public async Task <IActionResult> GetById(TRequest <int> request)
{
var response = new Response <object>();
try
{
response.Data = await _roomService.GetById(request.value);
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message + "," + ex.InnerException;
}
return(Ok(response));
}
private void button1_Click(object sender, EventArgs e)
{
string endpoint = "tcp://127.0.0.1:10000";
// Create
using (var context = new ZContext())
using (var requester = new ZSocket(context, ZSocketType.REQ))
{
// Connect
requester.Connect(endpoint);
Request req = new Request();
TRequest <Login> Treq = new TRequest <Login>();
Login login = new NetParser.Login();
LoginResponse loginresponse = new LoginResponse();
login.ID = "101";
login.loginDate = DateTime.Now;
login.password = "******";
login.user = "******";
login.response = loginresponse;
Treq.Data = login;
req.request = "login";
req.reqData = ProtoSerialize <TRequest <Login> >(Treq);
byte[] serReq = ProtoSerialize <Request>(req);
// Send
requester.Send(new ZFrame(serReq));
using (ZFrame reply = requester.ReceiveFrame())
{
Request answer = new Request();
answer = ProtoDeserialize <Request>(reply.Read());
Treq = ProtoDeserialize <TRequest <Login> >(answer.reqData);
if (Treq.Data.response.hasLogged)
{
Treq = ProtoDeserialize <TRequest <Login> >(answer.reqData);
richTextBox1.AppendText("Cookie: " + Treq.Data.response.cookie + Environment.NewLine + "Logged" + Treq.Data.response.hasLogged.ToString() + Environment.NewLine + "User: " + Treq.Data.response.user);
}
}
}
}
public void AssetIntoFile(OMV.UUID getID, OMV.AssetType type, string filename, AssetFetcherCompletionCallback doneCall)
{
m_totalRequests.Event();
if (File.Exists(filename)) {
m_requestsForExisting.Event();
// doneCall.BeginInvoke(getID, filename, null, null);
ThreadPool.QueueUserWorkItem((WaitCallback)delegate(Object x) {
// ThreadPool.UnsafeQueueUserWorkItem((WaitCallback)delegate(Object x) {
doneCall(getID, filename);
}, null);
}
lock (m_requests) {
if (!m_requests.ContainsKey(filename)) {
TRequest treq = new TRequest();
treq.ID = getID;
treq.Filename = filename;
treq.Type = type;
treq.DoneCall = doneCall;
treq.QueueTime = System.Environment.TickCount;
m_requests.Add(filename, treq);
}
else {
m_duplicateRequests.Event();
}
}
PushRequests();
}
