Esempio n. 1
0
        public async Task <CityViewModelResponse> GetTempByCity(string cityName)
        {
            var request = new HttpRequestMessage(HttpMethod.Get,
                                                 "http://api.openweathermap.org/data/2.5/weather?q=" + cityName + "&units=metric&lang=pt_br&appid=142d374d2ea6105f400f36546592a3d4");
            var client   = _clientFactory.CreateClient();
            var response = await client.SendAsync(request);

            Stream responseStream;

            if (!response.IsSuccessStatusCode)
            {
                responseStream = await response.Content.ReadAsStreamAsync();

                var objBadRequest = await JsonSerializer.DeserializeAsync
                                    <BadRequestViewModelAPI>(responseStream);

                throw new Exception(objBadRequest.message);
            }
            responseStream = await response.Content.ReadAsStreamAsync();

            var objApi = await JsonSerializer.DeserializeAsync
                         <CityAPI>(responseStream);

            return(_mapper.Map <CityViewModelResponse>(objApi));
        }
Esempio n. 2
0
        public async Task InvokeAsync(HttpContext context)
        {
            try
            {
                await _next(context);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                context.Response.ContentType = "application/json";
                context.Response.StatusCode  = (int)HttpStatusCode.InternalServerError;

                var response = _env.IsDevelopment()
                    ? new ApiException(context.Response.StatusCode, ex.Message, ex.StackTrace?.ToString())
                    : new ApiException(context.Response.StatusCode, "Internal Server Error");

                var options = new JsonSerializerOptions {
                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                };

                var json = JsonSerializer.Serialize(response, options);

                await context.Response.WriteAsync(json);

                ;
            }
        }
Esempio n. 3
0
        public IActionResult Details(int id)
        {
            Trace.WriteLine("ID = " + id);

            request = ConfigurationManager.AppSettings["baseUrl"] + ApiRoute.Films.FilmBase + "/" + ApiRoute.Films.GetFullFilmDetailsByIdFilm.Replace("{idFilm}", id.ToString());
            Trace.WriteLine(request);
            response = client.GetAsync(request).Result;
            Trace.WriteLine("Api Reponse: " + response.Content.ReadAsStringAsync().Result);

            if (!response.IsSuccessStatusCode)
            {
                throw new Exception("http fail full film");
            }

            FullFilmDTO film = JsonSerializer.Deserialize <ResponsePagine <FullFilmDTO> >(response.Content.ReadAsStringAsync().Result, options).Value;

            Trace.WriteLine(film.Title);

            //poster path
            HttpResponseMessage r = client.GetAsync(ConfigurationManager.AppSettings["movieAPI"] + film.Id + ConfigurationManager.AppSettings["appendKey"]).Result;

            if (!r.IsSuccessStatusCode)
            {
                throw new Exception("http fail poster path");
            }

            string s       = r.Content.ReadAsStringAsync().Result;
            var    data    = (JObject)JsonConvert.DeserializeObject(s);
            string newPath = data["poster_path"].Value <string>();

            film.PosterPath = ConfigurationManager.AppSettings["pathToPoster"] + newPath + ConfigurationManager.AppSettings["appendKey"];


            return(View(film));
        }
Esempio n. 4
0
        private Task OnJumpToState(JumpToStateCallback callbackInfo)
        {
            SequenceNumberOfCurrentState = callbackInfo.payload.actionId;
            using (Store.BeginInternalMiddlewareChange())
            {
                var newFeatureStates = Json.Deserialize <Dictionary <string, object> >(callbackInfo.state);
                foreach (KeyValuePair <string, object> newFeatureState in newFeatureStates)
                {
                    // Get the feature with the given name
                    if (!Store.Features.TryGetValue(newFeatureState.Key, out IFeature feature))
                    {
                        continue;
                    }

                    var    serializedFeatureStateElement = (JsonElement)newFeatureState.Value;
                    object stronglyTypedFeatureState     = Json.Deserialize(
                        json: serializedFeatureStateElement.ToString(),
                        returnType: feature.GetStateType(),
                        options: SerializationOptions);

                    // Now set the feature's state to the deserialized object
                    feature.RestoreState(stronglyTypedFeatureState);
                }
            }
            return(Task.CompletedTask);
        }
Esempio n. 5
0
        public ActionResult <string> UltimaAvaliacao([FromBody] dynamic rec)
        {
            lock (_system)
            {
                var jobject = JObject.Parse(JsonSerializer.Serialize(rec));

                if (!_system.isUserOnline(jobject.valueST.ToString()))
                {
                    return(Unauthorized("Client Offline"));
                }

                string email = jobject.email.ToString();

                Avaliaçao av = _system.GetUltAvaliaçaoR(email);

                if (av == null)
                {
                    return(NotFound("Utilizador ainda não tem Avaliaçoes"));
                }

                JObject job  = JObject.Parse(JsonConvert.SerializeObject(av));
                var     nome = _system.GetUser(email).GetName();
                //---------------- Patch
                job.Remove("id");
                job.Remove("realizada");
                job.Remove("instrutor_email");
                job.Add("comentario", " ");
                job.Add("massa_gorda_img", " ");
                job.Add("cliente_nome", nome);
                //------------
                return(Ok(job.ToString()));
            }
        }
Esempio n. 6
0
        string GetObjectInfo(object obj, string title)
        {
            if (obj == null)
            {
                return(string.Empty);
            }

            var strBuilder = new StringBuilder();

            strBuilder.AppendLine(title);
            strBuilder.AppendLine($"Type -> {obj.GetType().Name}");
            Type objType    = obj.GetType();
            var  resultProp = objType.GetProperties()
                              .FirstOrDefault(x => x.Name.Equals(nameof(FlowResult.Result)));
            var result = resultProp?.GetValue(obj);

            if (result != null)
            {
                var serialized = JsonSerializer.Serialize(obj,
                                                          options: new JsonSerializerOptions()
                {
                    PropertyNameCaseInsensitive = true,
                    IgnoreNullValues            = true,
                });
                strBuilder.AppendLine("Object result props:");
                strBuilder.AppendLine(serialized);
            }

            return(strBuilder.ToString());
        }
 public async Task SetTransforms(TransformCollection transforms)
 {
     using (var writer = File.CreateText(PATH)) {
         var json = JsonSerializer.Serialize(transforms);
         await writer.WriteLineAsync(json);
     }
 }
Esempio n. 8
0
        public static bool TryLoadCareer(string json, Assembly assembly, string gameData, out InstalledContentPack pack)
        {
            try
            {
                var metadata = JsonSerializer.Deserialize <ContentPackMetadata>(json, new JsonSerializerOptions
                {
                    IncludeFields = true
                });

                pack             = new InstalledContentPack();
                pack.Name        = metadata.Name;
                pack.Author      = metadata.Author;
                pack.Description = metadata.Description;

                pack._dataReader = () =>
                                   assembly.GetManifestResourceStream(gameData);

                return(true);
            }
            catch (Exception ex)
            {
                EntryPoint.CurrentApp.Logger.Log("Cannot load career mode data.");
                EntryPoint.CurrentApp.Logger.LogException(ex);
            }

            pack = null;
            return(false);
        }
Esempio n. 9
0
        public async Task <string> GetLocationsAsync(ClaimsPrincipal user)
        {
            int userid;

            if (!int.TryParse(user.Claims.FirstOrDefault(x => x.Type == "ID").Value, out userid))
            {
                return(null);
            }
            var User = await _context.Users
                       .Include(x => x.UserLocations)
                       .ThenInclude(y => y.Location)
                       .FirstOrDefaultAsync(x => x.UserID == userid);

            if (User != null)
            {
                var LocationNames = User.UserLocations.Select(x => new
                {
                    ID   = x.Location.ID,
                    Name = x.Location.Name
                }).ToList();
                var jsonLocations = JsonSerializer.Serialize(LocationNames);
                return(jsonLocations);
            }
            return(null);
        }
Esempio n. 10
0
        public async Task <string?> GetOrRefreshTokenAsync()
        {
            if (_lastUpdateToken.AddMinutes(25) >= SystemTime.Now())
            {
                return(_token);
            }

            using var client   = _httpClientFactory.CreateClient();
            client.BaseAddress = new Uri(_channel.MasterCommunication !.ToString());
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token);
            using var content = new StringContent(JsonSerializer.Serialize(_channel),
                                                  Encoding.Default, "application/json");
            var message = client.PutAsync(new Uri($"{client.BaseAddress}api/channel"), content);
            var result  =
                JsonSerializer.Deserialize <ConnectionInfo>(await(await message.ConfigureAwait(false)).Content.ReadAsStringAsync().ConfigureAwait(false), new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
            });

            _token           = result?.Token;
            _lastUpdateToken = SystemTime.Now();
            _logger.Information(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.SECURITY_TOKEN_UPDATED));

            return(_token);
        }
Esempio n. 11
0
        public async Task <List <ChannelInfo> > GetChannelsAsync()
        {
            var channels = MasterClientListSingleton.Instance.Channels;

            if (MasterClientListSingleton.Instance.Channels.Any())
            {
                return(channels);
            }

            using var client = _httpClientFactory.CreateClient();
            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Bearer", await GetOrRefreshTokenAsync().ConfigureAwait(false));

            var response = await client.GetAsync(new Uri($"{_channel.MasterCommunication}/api/channel")).ConfigureAwait(false);

            if (response.IsSuccessStatusCode)
            {
                var chan = JsonSerializer.Deserialize <List <ChannelInfo> >(await response.Content.ReadAsStringAsync()
                                                                            , new JsonSerializerOptions
                {
                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                });
                if (chan != null)
                {
                    channels = chan;
                    return(channels);
                }
            }

            throw new HttpRequestException();
        }
Esempio n. 12
0
        public async Task <Cell> GetCell(string queryString)
        {
            NpgsqlConnection _npgsqlConnection = new NpgsqlConnection(_databaseSettings.DatabaseConnectionString);
            await _npgsqlConnection.OpenAsync();

            using var cmd  = new NpgsqlCommand(queryString);
            cmd.Connection = _npgsqlConnection;
            var dataReader = await cmd.ExecuteReaderAsync();

            Cell cell = null;

            while (dataReader.Read())
            {
                cell = new Cell()
                {
                    CellId      = dataReader.GetFieldValue <int>(0),
                    DashboardId = dataReader.GetFieldValue <int>(1),
                    Input       = JsonSerializer.Deserialize <CellGraphData>(dataReader.GetFieldValue <JsonElement>(2).GetRawText()),
                    Options     = JsonSerializer.Deserialize <CellOptions>(dataReader.GetFieldValue <JsonElement>(3).GetRawText()),
                };
            }
            ;
            cmd.Parameters.Clear();
            await dataReader.CloseAsync();

            await _npgsqlConnection.CloseAsync();

            return(cell);
        }
Esempio n. 13
0
        public void IsDarkThemeRadioButtonCheckedShouldThemeToDarkWhenSuccessful()
        {
            // Arrange
            // Assert
            Func <string, int> SendMockIPCConfigMSG = msg =>
            {
                OutGoingGeneralSettings snd = JsonSerializer.Deserialize <OutGoingGeneralSettings>(msg);
                Assert.AreEqual("dark", snd.GeneralSettings.Theme);
                return(0);
            };

            Func <string, int> SendRestartAdminIPCMessage    = msg => { return(0); };
            Func <string, int> SendCheckForUpdatesIPCMessage = msg => { return(0); };
            GeneralViewModel   viewModel = new GeneralViewModel(
                settingsRepository: SettingsRepository <GeneralSettings> .GetInstance(mockGeneralSettingsUtils.Object),
                "GeneralSettings_RunningAsAdminText",
                "GeneralSettings_RunningAsUserText",
                false,
                false,
                UpdateUIThemeMethod,
                SendMockIPCConfigMSG,
                SendRestartAdminIPCMessage,
                SendCheckForUpdatesIPCMessage,
                generalSettingsFileName);

            Assert.IsFalse(viewModel.IsDarkThemeRadioButtonChecked);



            // act
            viewModel.IsDarkThemeRadioButtonChecked = true;
        }
Esempio n. 14
0
        public void RunElevatedShouldEnableAlwaysRunElevatedWhenSuccessful()
        {
            // Assert
            Func <string, int> SendMockIPCConfigMSG = msg =>
            {
                OutGoingGeneralSettings snd = JsonSerializer.Deserialize <OutGoingGeneralSettings>(msg);
                Assert.IsTrue(snd.GeneralSettings.RunElevated);
                return(0);
            };

            Func <string, int> SendRestartAdminIPCMessage    = msg => { return(0); };
            Func <string, int> SendCheckForUpdatesIPCMessage = msg => { return(0); };

            // Arrange
            GeneralViewModel viewModel = new GeneralViewModel(
                settingsRepository: SettingsRepository <GeneralSettings> .GetInstance(mockGeneralSettingsUtils.Object),
                "GeneralSettings_RunningAsAdminText",
                "GeneralSettings_RunningAsUserText",
                false,
                false,
                UpdateUIThemeMethod,
                SendMockIPCConfigMSG,
                SendRestartAdminIPCMessage,
                SendCheckForUpdatesIPCMessage,
                generalSettingsFileName);

            Assert.IsFalse(viewModel.RunElevated);

            // act
            viewModel.RunElevated = true;
        }
        public async Task <Response> RegisterUserAsync(RegisterModel model)
        {
            Uri uri = new Uri(string.Format(Constants.RegisterUrl, string.Empty));

            try
            {
                string              json     = JsonSerializer.Serialize <RegisterModel>(model, serializerOptions);
                StringContent       content  = new StringContent(json, Encoding.UTF8, "application/json");
                HttpResponseMessage response = null;
                response = await client.PostAsync(uri, content);

                string jsonresponse = await response.Content.ReadAsStringAsync();

                Response response2 = JsonSerializer.Deserialize <Response>(jsonresponse, serializerOptions);
                if (response.IsSuccessStatusCode)
                {
                    Debug.WriteLine(@"\user successfully created.");
                }
                return(response2);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(@"\tERROR {0}", ex.Message);
                return(new Response()
                {
                    Status = Constants.Status.Error, Message = Constants.APIMessages.ErrorOnRegisterFailed
                });
            }
        }
Esempio n. 16
0
        public async Task <ChannelInfo?> GetChannelAsync(int channelId)
        {
            var channels = MasterClientListSingleton.Instance.Channels;

            if (MasterClientListSingleton.Instance.Channels.Any())
            {
                return(channels?.FirstOrDefault(s => s.Id == channelId));
            }

            using var client   = _httpClientFactory.CreateClient();
            client.BaseAddress = new Uri(_channel.MasterCommunication !.ToString());
            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Bearer", await GetOrRefreshTokenAsync().ConfigureAwait(false));

            var response = await client.GetAsync(new Uri($"{_channel.MasterCommunication}/api/channel?id={channelId}")).ConfigureAwait(false);

            if (response.IsSuccessStatusCode)
            {
                channels = JsonSerializer.Deserialize <List <ChannelInfo> >(await response.Content.ReadAsStringAsync().ConfigureAwait(false)
                                                                            , new JsonSerializerOptions
                {
                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                });
            }

            return(channels?.FirstOrDefault(s => s.Id == channelId));
        }
        public async Task SaveUserAsync(ApplicationUser user, bool isNewUser)
        {
            Uri uri = new Uri(string.Format(Constants.GetUserUrl, string.Empty));

            try
            {
                string        json    = JsonSerializer.Serialize <ApplicationUser>(user, serializerOptions);
                StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
                client.DefaultRequestHeaders.Add("Authorization", $"Bearer {this.BearerToken}");

                HttpResponseMessage response = null;
                if (isNewUser)
                {
                    response = await client.PostAsync(uri, content);
                }
                else
                {
                    response = await client.PutAsync(uri, content);
                }

                if (response.IsSuccessStatusCode)
                {
                    Debug.WriteLine(@"\user successfully saved.");
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(@"\tERROR {0}", ex.Message);
            }
        }
        public static void Attaching_a_serialized_graph_4()
        {
            Console.WriteLine($">>>> Sample: {nameof(Attaching_a_serialized_graph_4)}");
            Console.WriteLine();

            Helpers.RecreateCleanDatabase();
            Helpers.PopulateDatabase();

            using var context = new BlogsContext();

            var posts = context.Posts.Include(e => e.Blog).ToList();

            #region Attaching_a_serialized_graph_4
            var serialized = JsonSerializer.Serialize(
                posts, new JsonSerializerOptions
            {
                ReferenceHandler = ReferenceHandler.Preserve,
                WriteIndented    = true
            });
            #endregion

            Console.WriteLine(serialized);

            UpdatePostsFromJson(serialized);
        }
Esempio n. 19
0
        public async Task CanDeserialize(SampleDataDescriptor sampleDataFile)
        {
            await using var sampleData = File.OpenRead(sampleDataFile.FullPath);
            var payload = await JsonSerializer.DeserializeAsync <TType>(sampleData, this.Options);

            Assert.NotNull(payload);
        }
        public async Task <Response> UpdateUserAsync(UpdateUserModel model)
        {
            Uri uri = new Uri(string.Format(Constants.UpdateUserProfileUrl, string.Empty));

            try
            {
                string        json    = JsonSerializer.Serialize <UpdateUserModel>(model, serializerOptions);
                StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
                client.DefaultRequestHeaders.Add("Authorization", $"Bearer {this.BearerToken}");

                HttpResponseMessage response = null;
                response = await client.PatchAsync(uri, content);

                string jsonresponse = await response.Content.ReadAsStringAsync();

                Response response2 = JsonSerializer.Deserialize <Response>(jsonresponse, serializerOptions);

                if (response.IsSuccessStatusCode)
                {
                    Debug.WriteLine(@"\user password successfully saved.");
                }
                return(response2);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(@"\tERROR {0}", ex.Message);
                return(new Response()
                {
                    Status = Constants.Status.Error, Message = Constants.APIMessages.ErrorOnUpdate
                });
            }
        }
Esempio n. 21
0
        public void Microsoft_JsonSerializer_should_throw_for_wrong_types()
        {
            Action act = () => JsonSerializer.Deserialize <Secret>("false");

            act.Should().Throw <System.Text.Json.JsonException>()
            .WithMessage("Cannot get the value of a token type 'False' as a string.");
        }
        public async Task <Response> DeleteUserAsync(string id)
        {
            Uri             uri       = new Uri(string.Format(Constants.DeleteUserUrl));
            DeleteUserModel userModel = new DeleteUserModel
            {
                UserId = id
            };

            try
            {
                string json    = JsonSerializer.Serialize <DeleteUserModel>(userModel, serializerOptions);
                var    content = new StringContent(json, Encoding.UTF8, "application/json");
                client.DefaultRequestHeaders.Add("Authorization", $"Bearer {this.BearerToken}");
                HttpResponseMessage response = await client.PostAsync(uri, content);

                string jsonresponse = await response.Content.ReadAsStringAsync();

                Response response2 = JsonSerializer.Deserialize <Response>(jsonresponse, serializerOptions);

                if (response.IsSuccessStatusCode)
                {
                    Debug.WriteLine(@"\user successfully deleted.");
                }
                return(response2);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(@"\tERROR {0}", ex.Message);
                return(new Response()
                {
                    Status = Constants.Status.Error, Message = Constants.APIMessages.ErrorOnDeletion
                });
            }
        }
Esempio n. 23
0
        public ActionResult <string> AvaliacoesAgendadas([FromBody] dynamic rec)
        {
            lock (_system)
            {
                var jobject = JObject.Parse(JsonSerializer.Serialize(rec));
                if (!_system.isUserOnline(jobject.valueST.ToString()))
                {
                    return(Unauthorized("Client Offline"));
                }

                string           email = jobject.email.ToString();
                List <Avaliaçao> av    = _system.GetAvaAgendCli(email);
                JArray           array = new JArray();
                foreach (Avaliaçao a in av)
                {
                    JObject tmp = new JObject();
                    tmp.Add("instrutor_email", a.instrutor_email);
                    tmp.Add("instrutor_nome", _system.GetUser(a.instrutor_email).GetName());
                    tmp.Add("data", a.data.ToString("yyyy-MM-dd HH:mm:ss"));
                    array.Add(tmp);
                }

                JObject avaliacoes = new JObject();
                avaliacoes.Add("avaliacoes", array);
                return(Ok(avaliacoes.ToString()));
            }
        }
        public async Task <ApplicationUser> GetUser(string username, string password)
        {
            ApplicationUser user = new ApplicationUser();

            dynamic jsonObject = new JObject();

            jsonObject.Username = username;
            jsonObject.Password = password;
            try
            {
                var content = new StringContent(jsonObject.ToString(), Encoding.UTF8, "application/json");
                client.DefaultRequestHeaders.Add("Authorization", $"Bearer {this.BearerToken}");
                var responseMessage = await client.PostAsync(Constants.GetUserUrl, content);

                if (responseMessage.IsSuccessStatusCode)
                {
                    string content2 = await responseMessage.Content.ReadAsStringAsync();

                    user = JsonSerializer.Deserialize <ApplicationUser>(content2, serializerOptions);
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(@"\tERROR {0}", ex.Message);
            }
            return(user);
        }
Esempio n. 25
0
        public XPaginationHeader(
            IPaginationMetadata pagination,
            Func <object, string> urlBuilder,
            CollectionConfig collectionConfig)
        {
            _collectionConfig = collectionConfig;
            var metadata = new
            {
                totalCount      = pagination.TotalCount,
                pageSize        = pagination.PageSize,
                currentPage     = pagination.CurrentPage,
                totalPages      = pagination.TotalPages,
                previousPageUrl = pagination.HasPrevious
                    ? CreatePlayersResourceUri(ResourceUriType.PreviousPage, urlBuilder)
                    : null,
                nextPageUrl = pagination.HasNext
                    ? CreatePlayersResourceUri(ResourceUriType.NextPage, urlBuilder)
                    : null
            };

            var key   = "X-Pagination";
            var value = JsonSerializer.Serialize(metadata,
                                                 new JsonSerializerOptions()
            {
                // NOTE: Stops the '?' & '&' chars in the links being escaped
                Encoder          = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
                IgnoreNullValues = true
            });

            Value = new KeyValuePair <string, StringValues>(key, value);
        }
        public async Task <List <Message> > GetMessageDataAsync(string UserId)
        {
            List <Message> Messages = new List <Message>();

            Uri uri = new Uri(string.Format(Constants.MessageUrl, UserId));

            try
            {
                client.DefaultRequestHeaders.Add("Authorization", $"Bearer {this.BearerToken}");
                HttpResponseMessage response = await client.GetAsync(uri);

                if (response.IsSuccessStatusCode)
                {
                    string content = await response.Content.ReadAsStringAsync();

                    if (!string.IsNullOrEmpty(content))
                    {
                        Messages = JsonSerializer.Deserialize <List <Message> >(content, serializerOptions);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(@"\tERROR {0}", ex.Message);
            }

            return(Messages);
        }
        public static async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
            [SendGrid(ApiKey = "CustomSendGridKeyAppSettingName")] IAsyncCollector <SendGridMessage> messageCollector,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");
            var options = new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true,
            };
            var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            var meeting     = JsonSerializer.Deserialize <DeaconMeeting>(requestBody, options);

            try
            {
                var message = new SendGridMessage();
                var worker  = new MessageWorker(message);

                meeting.Email     = Environment.GetEnvironmentVariable("DeaconMeetingEmail");
                meeting.Name      = Environment.GetEnvironmentVariable("DeaconMeetingName");
                meeting.FromEmail = Environment.GetEnvironmentVariable("DeaconMeetingFromEmail");
                meeting.FromName  = Environment.GetEnvironmentVariable("DeaconMeetingFromName");
                meeting.Copy      = Environment.GetEnvironmentVariable("DeaconMeetingCopy");

                await messageCollector.AddAsync(worker.PrepareDiaconateMeetingEmail(meeting));
            }
            catch (Exception e)
            {
                log.LogInformation(e.ToString());
                return(new BadRequestResult());
            }


            return(new OkResult());
        }
        public async Task <Response> UpdateMessageAsync(int id)
        {
            Uri uri = new Uri(string.Format(Constants.MessageUrl, id));

            try
            {
                client.DefaultRequestHeaders.Add("Authorization", $"Bearer {this.BearerToken}");
                HttpResponseMessage response = null;
                response = await client.PatchAsync(uri, null);

                string jsonresponse = await response.Content.ReadAsStringAsync();

                Response response2 = JsonSerializer.Deserialize <Response>(jsonresponse, serializerOptions);

                if (response.IsSuccessStatusCode)
                {
                    Debug.WriteLine(@"\food successfully saved.");
                }
                return(response2);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(@"\tERROR {0}", ex.Message);
                return(new Response()
                {
                    Status = Constants.Status.Error, Message = Constants.APIMessages.ErrorOnUpdate
                });
            }
        }
Esempio n. 29
0
        async Task WriteCache(List <StakePool> allPools)
        {
            BlockChainCache = new BlockChainCache
            {
                StakePools = new ObservableCollection <StakePool>(allPools),
                CacheDate  = DateTime.Now
            };

            var options = new JsonSerializerOptions
            {
                WriteIndented = true
            };

            byte[] jsonUtf8Bytes = JsonSerializer.SerializeToUtf8Bytes(BlockChainCache, options);


            if (BlockChainCache.StakePools.Any())
            {
                BlockChainCache.StakePools.Clear();
            }
            OnPropertyChanged("BlockChainCache");

            if (!_stakePoolListDatabase.HasWritePermissionOnDir())
            {
                throw new Exception(string.Format(
                                        "Failed caching to local system. Software can still be used but without caching it results in slower performance. {0}No write permission for: {1}",
                                        Environment.NewLine, _stakePoolListDatabase));
            }
            await File.WriteAllBytesAsync(_stakePoolListDatabase, jsonUtf8Bytes);
        }
        public async Task Update(Category category)
        {
            var categoryJson =
                new StringContent(JsonSerializer.Serialize(category), Encoding.UTF8, "application/json");

            await _httpClient.PutAsync("api/category", categoryJson);
        }