public Project AddUnauthorizePartner(KeyValuePair <string, string> pair, RestViewModal modal)
{
PrService service = new PrService()
{
Services = modal.Services,
UserName = pair.Key,
Password = pair.Value,
};
service.Request = new List <ProjectServer>();
var projectSerice = new ProjectServer()
{
UserName = pair.Key,
Password = pair.Value,
Url = modal.Url
};
service.Request.Add(projectSerice);
Project newProject = new Project()
{
ProjectService = new List <PrService>()
{
service
}, IsActive = false, DateTime = DateTime.Now, PrjectStatus = AuthModel.Enum.UserStatus.NotActivated,
};
Add(newProject); return(newProject);
}
public async Task <ResponseData> SendOtp(string phoneNumber, string orginator = "3700")
{
try
{
var partner = this.GetProject(_project, DefaultRest);
var message = SendModal.Create(partner);
partner.RunConfig(_confList, message);
message.Messages.Add(new Message()
{
Recipient = RepositoryState.ParsePhone(phoneNumber), MessageId = "123456", Sms = new Sms()
{
Originator = orginator, Content = new Entity.Sms.Content()
}
});
RestViewModal viewModal = new RestViewModal()
{
Header = Request.Headers.ToDict()
};
var result = await _message.SendOtp(partner, message, viewModal);
return(this.GetResponse(result));
}
catch (Exception ext)
{
return(this.GetResponse());
}
}
public RestClient CreateClient(string url, RestViewModal viewModal)
{
RestClient client = new RestClient(url);
client.Timeout = 20000;
AddHeaders(client, viewModal.Header);
return(client);
}
public async Task <IRestResponse> SendUnuthorize(RestViewModal model)
{
var packet = Start(model);
var result = await _req.Send(model);
SaveUnAuthorize(packet, result);
return(result);
}
public async Task <IRestResponse> Send(string url, RestViewModal model = null)
{
var client = CreateClient(url, model);
RestRequest request = CreateRequest(model);
var result = client.Execute(request);
return(result);
}
public Packets Start(RestViewModal model)
{
var watch = Stopwatch.StartNew();
model.StopWatch = Stopwatch.StartNew();
var packet = Packets.Create(model);
return(packet);
}
public async Task <IRestResponse> Send(Config config, RestViewModal model)
{
var client = CreateClient(config.RequestUrl, model);
ParseClient(config, model, client);
var request = CreateRequest(model);
return(client.Execute(request));
}
public async Task <IRestResponse> Send(ProjectServer server, RestViewModal model)
{
var client = CreateClient(server.Url, model);
ParseServer(server, model, client);
var request = CreateRequest(model);
return(client.Execute(request));
}
public async Task <IRestResponse> Send(RestViewModal model)
{
RestClient client = new RestClient(model.Url);
AddHeaders(client, model.Header);
var request = CreateRequest(model);
return(client.Execute(request));
}
public async Task <IRestResponse> Send(ProjectServer server, RestViewModal model, SendModal sms)
{
var client = CreateClient(server.Url, model);
ParseServer(server, model, client);
RestRequest request = new RestRequest(Method.POST);
request.AddJsonBody(sms);
return(client.Execute(request));
}
public Task FromRequest([FromBody] RestViewModal modal)
{
var projectName = Request.Headers.FirstOrDefault(m => m.Key.ToLower() == "coroname").Value;
if (string.IsNullOrEmpty(projectName))
{
return(Task.Factory.StartNew(async() => await SendUnuthorize(_provider, modal)));
}
return(Task.Factory.StartNew(async() => await SendAuthorize(_provider, modal)));
}
public static Packets Create(RestViewModal viewmodal)
{
Packets newPacket = new Packets()
{
FromUrl = viewmodal.FromIp,
Date = new DateTime(),
RestPacket = viewmodal,
};
return(newPacket);
}
public async Task <IRestResponse> SendAuthorize(RestViewModal model, Project project)
{
var packet = Start(model);
var service = project.GetServices(Entity.Enum.Services.Rest).FirstOrDefault(m => m.BaseUrl == model.BaseUrl());
if (service != null)
{
Entity.State.ParseService(service, model);
}
var result = await _req.Send(model);
packet.ProjectId = project.Id;
SaveAuthorize(packet, result);
return(result);
}
private async Task SendAuthorize(IServiceProvider provider, RestViewModal modal)
{
var packet = provider.GetService <IPacketsService>();
var dict = Request.Headers.ToDict();
var userPass = dict.Coro();
if (userPass == null)
{
}
var coro = userPass.GetValueOrDefault();
var _project = provider.GetService <IProjectService>();
var project = _project.GetFirst(m => m.Name == coro.Key && m.Password == coro.Value);
var item = await packet.SendAuthorize(modal, project);
this.ConvertRest(item);
}
private async Task SendUnuthorize(IServiceProvider provider, RestViewModal model)
{
try
{
var ip = this.HttpContext.Connection.RemoteIpAddress.ToString();
model.FromIp = ip;
var packet = provider.GetService <IPacketsService>();
var dict = Request.Headers.ToDict();
model.Header = dict;
var item = await packet.SendUnuthorize(model);
this.ConvertRest(item);
}
catch (Exception ext)
{
Console.WriteLine(ext.Message);
}
}
public RestRequest CreateRequest(RestViewModal model)
{
RestSharp.Method method = Method.GET;
switch (model.Method)
{
case Entity.Enum.Method.Post: { method = Method.POST; } break;
case Entity.Enum.Method.Put: { method = Method.PUT; } break;
case Entity.Enum.Method.Delete: { method = Method.DELETE; } break;
}
RestRequest request = new RestRequest(method);
if (model.Data != null)
{
// request.AddJsonBody(model.Data);
var postData = JsonConvert.SerializeObject(model.Data);
byte[] data = Encoding.GetEncoding("UTF-8").GetBytes(postData);
request.AddHeader("cache-control", "no-cache");
request.AddParameter("application/json; charset=utf-8", data, ParameterType.RequestBody);
request.AddJsonBody(data);
}
return(request);
}
public static void ParseService(ProjectServices service, RestViewModal model)
{
}
public async Task <IRestResponse> Send(ProjectServer server, RestViewModal modal)
{
return(await _req.Send(server, modal));
}
public void ParseClient(Config config, RestViewModal model, RestClient client)
{
}
public void ParseServer(ProjectServer server, RestViewModal model, RestClient client)
{
}
