private void Write(Dictionary <string, object> requestProperties)
{
List <TypedItem> list = requestProperties.ToTypedItems();
if (eXtensibleWebApiConfig.LogTo.Equals(LoggingStrategyOption.Datastore))
{
try
{
ApiRequest request = new ApiRequest(requestProperties);
RequestProvider.Post(request);
//ApiRequestSqlAccess.Post(request);
}
catch (Exception ex)
{
EventWriter.Write(EventTypeOption.Custom, list);
string message = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
var properties = eXtensibleConfig.GetProperties();
properties.Add("xf.explanation", "An error occurred while trying to POST an ApiRequest to a SqlServer datastore. " +
" Ensure that a valid SqlServer database exists with the proper schema, and that a valid connectionstring and connectionstring key");
EventWriter.WriteError(message, SeverityType.Error, "eXtensibleMessageHandler", properties);
}
}
else if (eXtensibleWebApiConfig.LogTo.Equals(LoggingStrategyOption.WindowsEventLog))
{
EventWriter.Write(EventTypeOption.Custom, list);
}
}
public override async Task <List <LogisticStore> > GetItemsAsync(SystemSearchParameter systemSearch = null)
{
this.RunUrl = GlobalSetting.Instance.GatewayLogisticEndpoint + "/api/LogisticStoreAuthorize/MyStores";
try
{
var httpclient = RequestProvider.CreateHttpClient();
var token = await httpclient.ReadSystemAccessToken();
httpclient = RequestProvider.CreateHttpClient(token);
var searchurl = new UrlBuilder().Build(RunUrl, systemSearch);
var searchresult = await httpclient.GetStringAsync(searchurl).ConfigureAwait(false);
return(await Task.Run(() =>
JsonConvert.DeserializeObject <List <LogisticStore> >(searchresult)));
// return base.GetItemsAsync(null);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_requestProvider = new RequestProvider(context);
_wordFilterService = new WordFilterService(context.Update.Message);
var msg = context.Update.Message;
var cleanedMsg = msg.Text.GetTextWithoutCmd();
var partedMsg = cleanedMsg.Split(" ");
var paramOption = partedMsg.ValueOfIndex(1);
var word = partedMsg.ValueOfIndex(0);
var isGlobalBlock = false;
var isSudoer = _requestProvider.IsSudoer();
var isAdmin = await _requestProvider.IsAdminGroup();
if (isSudoer || isAdmin)
{
var where = new Dictionary <string, object>()
{
{ "word", word }
};
if (paramOption == "-g" && isSudoer)
{
isGlobalBlock = true;
await _requestProvider.SendTextAsync("Kata ini akan di blokir dengan mode Group-wide!");
}
if (!isSudoer)
{
await _requestProvider.SendTextAsync("Hanya Sudoer yang dapat memblokir Kata mode Group-wide!");
}
if (paramOption != "-g")
{
where.Add("chat_id", msg.Chat.Id);
}
if (word != "")
{
var isExist = await _wordFilterService.IsExistAsync(where);
if (!isExist)
{
var save = await _wordFilterService.SaveWordAsync(word, isGlobalBlock);
await _requestProvider.SendTextAsync(save.ToJson());
}
else
{
await _requestProvider.SendTextAsync("Sudah");
}
}
else
{
await _requestProvider.SendTextAsync("Apa kata?");
}
}
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddServerSideBlazor();
services.AddSingleton <WeatherForecastService>();
var ssi = new SettingsServiceImplementation();
var dp = new DependencyService(ssi);
var ss = new SettingsService(dp);
var ts = new TokenService(ss);
var rp = new RequestProvider();
var nec = new HttpNeuronClient(rp, ts);
var esf = new IO.Process.Services.Events.EventSourceFactory();
var nas = new NotificationApplicationService(esf);
var neas = new NeuronApplicationService(nec);
var nqc = new HttpNeuronQueryClient(rp, ts);
var nqs = new NeuronQueryService(nqc);
services.AddSingleton <IDependencyService>(dp);
services.AddSingleton <ISettingsService>(ss);
services.AddSingleton <IRequestProvider>(rp);
services.AddSingleton <IIdentityService>(new IdentityService(ss, rp));
services.AddSingleton <IEventSourceFactory>(esf);
services.AddSingleton <INotificationApplicationService>(nas);
services.AddSingleton <INeuronClient>(nec);
services.AddSingleton <INeuronApplicationService>(neas);
services.AddSingleton <ITokenService>(ts);
services.AddSingleton <INeuronQueryClient>(nqc);
services.AddSingleton <INeuronQueryService>(nqs);
}
public void GetQueryValueOrDefault_GivenActualCases_ReturnExpected <T>(string key, T expected)
{
var provider = new RequestProvider(_httpContextBase);
var result = provider.GetQueryValueOrDefault <T>(key);
Assert.AreEqual(result, expected);
}
private static void LoadProvider()
{
// if we do not have initiated the provider
if (_provider == null)
{
lock (_lock)
{
// Do this again to make sure _provider is still null
if (_provider == null)
{
// Get a reference to the <requestService> section
RequestServiceSection section = (RequestServiceSection)WebConfigurationManager.GetSection("LCSK/requestService");
// Load the default provider
if (section.Providers.Count > 0 && !string.IsNullOrEmpty(section.DefaultProvider) && section.Providers[section.DefaultProvider] != null)
{
_provider = (RequestProvider)ProvidersHelper.InstantiateProvider(section.Providers[section.DefaultProvider], typeof(RequestProvider));
}
if (_provider == null)
{
throw new ProviderException("Unable to load the RequestProvider");
}
}
}
}
}
public static async Task AfkCheck(this RequestProvider requestProvider, Message message)
{
var afkService = new AfkService();
if (message.ReplyToMessage != null)
{
var repMsg = message.ReplyToMessage;
var isAfkReply = await afkService.IsAfkAsync(repMsg);
if (isAfkReply)
{
await requestProvider.SendTextAsync($"{repMsg.GetFromNameLink()} sedang afk");
}
}
var isAfk = await afkService.IsAfkAsync(message);
if (isAfk)
{
await requestProvider.SendTextAsync($"{message.GetFromNameLink()} sudah tidak afk");
var data = new Dictionary <string, object>()
{
{ "chat_id", message.Chat.Id },
{ "user_id", message.From.Id },
{ "is_afk", 0 },
{ "afk_reason", "" }
};
await afkService.SaveAsync(data);
await afkService.UpdateCacheAsync();
}
}
static ViewModelLocator()
{
// Services - by default, TinyIoC will register interface registrations as singletons.
var settingsService = new SettingsService();
var requestProvider = new RequestProvider();
Xamarin.Forms.DependencyService.RegisterSingleton <ISettingsService>(settingsService);
Xamarin.Forms.DependencyService.RegisterSingleton <INavigationService>(new NavigationService(settingsService));
Xamarin.Forms.DependencyService.RegisterSingleton <IDialogService>(new DialogService());
Xamarin.Forms.DependencyService.RegisterSingleton <IOpenUrlService>(new OpenUrlService());
Xamarin.Forms.DependencyService.RegisterSingleton <IRequestProvider>(requestProvider);
Xamarin.Forms.DependencyService.RegisterSingleton <IIdentityService>(new IdentityService(requestProvider));
Xamarin.Forms.DependencyService.RegisterSingleton <IDependencyService>(new Services.Dependency.DependencyService());
Xamarin.Forms.DependencyService.RegisterSingleton <IFixUriService>(new FixUriService(settingsService));
Xamarin.Forms.DependencyService.RegisterSingleton <ILocationService>(new LocationService(requestProvider));
Xamarin.Forms.DependencyService.RegisterSingleton <ICatalogService>(new CatalogMockService());
Xamarin.Forms.DependencyService.RegisterSingleton <IBasketService>(new BasketMockService());
Xamarin.Forms.DependencyService.RegisterSingleton <IOrderService>(new OrderMockService());
Xamarin.Forms.DependencyService.RegisterSingleton <IUserService>(new UserMockService());
Xamarin.Forms.DependencyService.RegisterSingleton <ICampaignService>(new CampaignMockService());
// View models - by default, TinyIoC will register concrete classes as multi-instance.
Xamarin.Forms.DependencyService.Register <BasketViewModel> ();
Xamarin.Forms.DependencyService.Register <CatalogViewModel> ();
Xamarin.Forms.DependencyService.Register <CheckoutViewModel> ();
Xamarin.Forms.DependencyService.Register <LoginViewModel> ();
Xamarin.Forms.DependencyService.Register <MainViewModel> ();
Xamarin.Forms.DependencyService.Register <OrderDetailViewModel> ();
Xamarin.Forms.DependencyService.Register <ProfileViewModel> ();
Xamarin.Forms.DependencyService.Register <SettingsViewModel> ();
Xamarin.Forms.DependencyService.Register <CampaignViewModel> ();
Xamarin.Forms.DependencyService.Register <CampaignDetailsViewModel> ();
}
public HistoryViewModel(INavigation navigation, Page context, ListView listView, BaseViewModel viewModelContext = null)
{
this.Navigation = navigation;
this.CurrentPage = context;
this.ListView = listView;
this.ViewModelContext = viewModelContext;
requestProvider = new RequestProvider();
if (ViewModelContext == null)
{
urlLoadBidHistory = GlobalSetting.Instance.BidGetEndpoint;
}
else
{
IsModalMode = true;
var bettingViewModel = ViewModelContext as BettingViewModel;
if (bettingViewModel != null)
{
urlLoadBidHistory = GlobalSetting.Instance.BidGetByIdEndpoint
+ "?bettingId=" + bettingViewModel.SelectedItem.BettingId;
}
}
Task.Run(async() => await LoadBidItems());
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
// ChatHelper.Init(context);
response = new RequestProvider(context);
// var chatId = ChatHelper.Message.Chat.Id.ToString();
// var isAdmin = await ChatHelper.IsAdminGroup();
var chatId = response.Message.Chat.Id.ToString();
var isAdmin = await response.IsAdminGroup();
if (isAdmin || response.IsPrivateChat())
{
#pragma warning disable 4014
Task.Run(async() =>
#pragma warning restore 4014
{
// Thread.CurrentThread.IsBackground = true;
await response.SendTextAsync("Sedang memeriksa RSS feed baru..");
// await "Sedang memeriksa RSS feed baru..".SendTextAsync();
var newRssCount = await RssHelper.ExecBroadcasterAsync(chatId);
if (newRssCount == 0)
{
await response.EditAsync("Tampaknya tidak ada RSS baru saat ini");
// await "Tampaknya tidak ada RSS baru saat ini".EditAsync();
}
// ChatHelper.Close();
}, cancellationToken);
}
}
protected void GridView_InitNewRow(object sender, DevExpress.Web.Data.ASPxDataInitNewRowEventArgs e)
{
RequestVM CloneItem = new RequestVM();
if (HttpContext.Current.Session["isCloneRow_Com"] != null && bool.Parse(HttpContext.Current.Session["isCloneRow_Com"].ToString()) == true && GridView.FocusedRowIndex >= 0)
{
//List<int> selectedIds = GridView.GetSelectedFieldValues("Id").ConvertAll(id => (int)id);
//CloneItem = StandardTypeProvider.GetSingleById(selectedIds.Last());
CloneItem = Mapper.Map <RequestVM>(RequestProvider.GetSingleById(int.Parse(GridView.GetRowValues(GridView.FocusedRowIndex, "Id").ToString())));
HttpContext.Current.Session["isCloneRow_Com"] = false;
PropertyInfo myFieldInfo;
foreach (var myProperty in typeof(RequestVM).GetProperties())
{
myFieldInfo = typeof(RequestVM).GetProperty(myProperty.Name);
if (myFieldInfo == null)
{
continue;
}
var ttt = myFieldInfo.GetValue(CloneItem);
e.NewValues[myProperty.Name] = myFieldInfo.GetValue(CloneItem);
}
}
e.NewValues["RegistedDate"] = DateTime.Now;
e.NewValues["HoldEquipNo"] = 1;
e.NewValues["RegisteredNo"] = SysConfigProvider.GetRegisteredNo(DateTime.Now.Year).ValueInt.FomatStringNo(DateTime.Now.Year, "/PĐK");
}
public HttpResponseMessage Get(string id)
{
//NameValueCollection nvc = Request.GetApiParameters(new FacetEndpointMediaSettings());
HttpResponseMessage message = null;
int pageSize;
Guid g; // either basic token or apirequest messageid
if (String.IsNullOrEmpty(id)) // if absent, set pageSize
{
pageSize = 10;
var data = RequestProvider.Get(pageSize);
message = Request.CreateResponse(data);
}
else if (Int32.TryParse(id, out pageSize))
{
var data = RequestProvider.Get(pageSize);
message = Request.CreateResponse(data);
}
else if (Guid.TryParse(id, out g))
{
var data = RequestProvider.Get(g);
message = Request.CreateResponse(data);
}
else
{
var data = RequestProvider.Get(id);
message = Request.CreateResponse(data);
}
return(message);
}
public async Task HandleAsync(IUpdateContext context, UpdateDelegate next, CancellationToken cancellationToken)
{
_requestProvider = new RequestProvider(context);
if (context.Update.ChannelPost != null)
{
return;
}
var message = context.Update.Message ?? context.Update.CallbackQuery.Message;
Log.Information("New Update");
var actions = new List <Action>();
actions.Add(async() => await _requestProvider.AfkCheck(message));
actions.Add(async() => await _requestProvider.CheckCasBanAsync(message.From));
actions.Add(async() => await _requestProvider.CheckUsername(message));
actions.Add(async() => await _requestProvider.FindNotesAsync(message));
actions.Add(() => ActivityHelper.HitActivityBackground(message));
if (context.Update.CallbackQuery == null)
{
actions.Add(async() => await _requestProvider.CheckMessage(message));
}
if (!_requestProvider.IsPrivateChat())
{
actions.Add(async() => await _requestProvider.CheckGlobalBanAsync(message));
}
Parallel.Invoke(actions.ToArray());
await next(context, cancellationToken);
}
public async void OnSubmit()
{
var provider = new RequestProvider();
var Login = new { CPF, SUS };
if (Connectivity.NetworkAccess == NetworkAccess.Internet || Connectivity.NetworkAccess == NetworkAccess.Local)
{
try
{
using (Acr.UserDialogs.UserDialogs.Instance.Loading("Realizando Login..."))
{
Application.Current.Properties.Remove("Usuario");
var entity = await provider.PostAsync <Usuarios>(_URL, Login);
Application.Current.Properties.Add("Usuario", entity);
}
App.UsuarioLogado = true;
await NavegarParaPaginaPrincipal();
}
catch (Exception ex)
{
App.UsuarioLogado = false;
await Task.Delay(100);
ExibirAvisoDeLoginInvalido("Login Inválido, tente novamente");
}
}
else
{
ExibirAvisoDeLoginInvalido("Sem conexão com a internet");
}
}
private void Write(Dictionary <string, object> requestProperties)
{
List <TypedItem> list = requestProperties.ToTypedItems();
if (eXtensibleWebApiConfig.LogTo.Equals(LoggingStrategyOption.WindowsEventLog))
{
EventWriter.Write(EventTypeOption.Custom, list);
}
else if (RequestProvider != null)
{
try
{
ApiRequest request = new ApiRequest(requestProperties);
RequestProvider.Post(request);
}
catch (Exception ex)
{
EventWriter.Write(EventTypeOption.Custom, list);
string message = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
var properties = eXtensibleConfig.GetProperties();
properties.Add("xf.explanation", "An error occurred while trying to POST an ApiRequest to the configured ApiRequestProvider");
EventWriter.WriteError(message, SeverityType.Error, "eXtensibleMessageHandler", properties);
}
}
else
{
EventWriter.Write(EventTypeOption.Custom, list);
}
}
public async Task <IList <ISpiderContainer> > GetContainerAsync(UriItem url)
{
var items = new List <ISpiderContainer>();
var rules = RuleProvider.Get(url.Source);
if (rules == null || rules.Count < 1)
{
return(items);
}
var shouldPrepare = false;
foreach (var item in rules)
{
items.Add(GetContainer(url, PluginLoader.Render(item.Rules, ref shouldPrepare)));
}
if (!shouldPrepare)
{
return(items);
}
var content = await RequestProvider.Getter().GetAsync(url.Source, Option.HeaderItems, ProxyProvider.Get());
if (content == null)
{
Logger?.Waining($"{url.Source} HTML EMPTY");
items.Clear();
return(items);
}
url.Title = Html.MatchTitle(content);
foreach (var item in items)
{
item.Data = new RuleString(content);
}
return(items);
}
public QueueService()
{
factory = new ConnectionFactory()
{
HostName = "localhost"
};
connection = factory.CreateConnection();
channel = connection.CreateModel();
channel.QueueDeclare(queue: "Pay",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
Message message = body.FromByteArray <Message>();
messages.Add(message);
RequestProvider requestProvider = new RequestProvider();
//Task.Run(()=> requestProvider.ProcessFee(message.UserId, message.Amount));
Thread t = new Thread(new ParameterizedThreadStart(requestProvider.ProcessFee));
t.Start(message);
Debug.WriteLine("Message: {0} received", message.Id);
};
channel.BasicConsume(queue: "Pay",
autoAck: true,
consumer: consumer);
}
public async Task GetCatalogTypeTest()
{
var requestProvider = new RequestProvider();
var catalogService = new CatalogService(requestProvider);
var catalogType = await catalogService.GetCatalogTypeAsync();
Assert.NotEqual(0, catalogType.Count);
}
private void PushToWorker(IAsyncResult callback)
{
if (m_listener.IsListening)
{
var provider = new RequestProvider(this, callback);
m_requestProcessor.Process(provider);
}
}
public virtual async Task <List <T> > GetItemsAsync(SystemSearchParameter systemSearch)
{
var accesstoken = await RequestProvider.CreateHttpClient().ReadSystemAccessToken();
return(await RequestProvider.GetAsync <List <T> >(RunUrl, systemSearch, accesstoken));
// return await Task.Run< List<T>>(() => JsonConvert.DeserializeObject<List<T>>(readresult)); ;
}
public async Task GetOrdersTest()
{
var requestProvider = new RequestProvider();
var ordersService = new OrderService(requestProvider);
var result = await ordersService.GetOrdersAsync(GlobalSetting.Instance.AuthToken);
Assert.NotEqual(0, result.Count);
}
public ContactListViewModel(Page context)
{
_requestProvider = new RequestProvider();
_context = context;
Device.BeginInvokeOnMainThread(async() =>
ContactsList = await DependencyService.Get <IContactService>().GetContactListAsync());
}
public MainWindow()
{
InitializeComponent();
RequestProvider requestProvider = RequestProvider.Create();
Task.Run(() => requestProvider.Run());
}
public DefaultSpider(ILogger?logger, IPluginLoader plugin)
{
UrlProvider = new UrlProvider(this);
RequestProvider = new RequestProvider(this);
RuleProvider = new RuleProvider(this);
Storage = new StorageProvider(this);
Logger = logger;
PluginLoader = plugin;
}
private static MovieService CreateMovieService()
{
var requestProvider = new RequestProvider();
var settingService = new SettingsService();
var genreService = new GenreService(requestProvider, settingService);
var movieService = new MovieService(requestProvider, settingService, genreService);
return(movieService);
}
public void SendRequest_WhenBadHostSpec_UnhandledException()
{
HostSpec badApiHost = new HostSpec(ChangeScheme(ConfigHelper.Scheme), ConfigHelper.Host, ConfigHelper.Port);
ID2LUserContext badAnonContext = ContextProvider.AnonUserContext(badApiHost);
HttpWebRequest request = RequestProvider.PrepareApiRequest(badAnonContext, RouteProvider.VersionsRoute);
Assert.Throws <WebException>(() => { using (HttpWebResponse response = request.GetResponse() as HttpWebResponse) { } });
}
public void SendRequest_AtUrlForAuthentication_ResponseReceived()
{
Uri landingUrl = new UriBuilder(ConfigHelper.Scheme, ConfigHelper.Host, ConfigHelper.Port, RouteProvider.OrganizationInfoRoute).Uri;
Uri uri = ContextProvider.AuthenticatedUrl(landingUrl);
HttpWebRequest request = RequestProvider.CreateRequest(uri);
Assert.DoesNotThrow(() => { using (HttpWebResponse response = request.GetResponse() as HttpWebResponse) { } });
}
public async Task ServiceShouldReturnGenres()
{
var requestProvider = new RequestProvider();
var settingService = new SettingsService();
var genreService = new GenreService(requestProvider, settingService);
var genres = await genreService.GetGenresAsync();
Assert.NotEmpty(genres);
}
public BettingViewModel(INavigation navigation, Page context, ListView listView)
{
this.Navigation = navigation;
this.CurrentPage = context;
this.ListView = listView;
requestProvider = new RequestProvider();
Task.Run(async() => await LoadAddressItems());
}
public bool IsVerifiedyBy(int RequestId)
{
var item = RequestProvider.GetSingleByCondition(x => x.Id == RequestId && x.VerifiedyBy == UserName);
if (item == null)
{
return(false);
}
return(true);
}
HttpWebResponse Stage2(RequestProvider requestProvider, ServiceAction action,
WebHeaderCollection headers, int retry, Stream stream)
{
var request = requestProvider (action, headers);
if (fallback.Chuncked) {
return Stage2 (request, action, retry, stream, Stage3Chuncked, Stage3Unchunked);
} else {
return Stage2 (request, action, retry, stream, Stage3Unchunked, Stage3Chuncked);
}
}
HttpWebResponse Stage1(ServiceAction action, WebHeaderCollection headers, int retry, Stream stream,
RequestProvider requestProvider1, RequestProvider requestProvider2)
{
var response = Stage2 (requestProvider1, action, headers, retry, stream);
if (response.StatusCode == HttpStatusCode.MethodNotAllowed) {
response = Stage2 (requestProvider2, action, headers, retry, stream);
}
return response;
}
