Example #1
0
        public async Task UpdateRealmAsync(Guid correlationRefId, RealmUpdateRequest realm, CancellationToken cancellationToken = default)
        {
            HttpResponseMessage httpResponse = await SendAsJsonAsync(
                method : HttpMethod.Put,
                pathAndQuery : $"api/v1/realm",
                correlationRefId : correlationRefId,
                request : realm,
                requestHeaders : null,
                cancellationToken).ConfigureAwait(false);

            string responseJson = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);

            var response = JsonConvert.DeserializeObject <SmartResponse <string> >(responseJson);

            if (httpResponse.IsSuccessStatusCode)
            {
                return;
            }

            throw new Exception($"Update Realm failed. {response.Error.Message}");
        }
Example #2
0
        public async Task <RealmUpdateResponse> UpdateRealm(ClaimsPrincipal claim, RealmUpdateRequest request)
        {
            var response = new RealmUpdateResponse();
            var user     = await _userService.GetCurrentUser(claim);

            var userId = user == null ? string.Empty : user.Id;

            if (string.IsNullOrEmpty(userId))
            {
                response.ErrorMessages.Add("You are not authorised to perform this action.");
                return(response);
            }

            var realm = await _realmDataService.GetRealmById(request.Id);

            if (realm == null)
            {
                response.ErrorMessages.Add("Realm not found.");
                return(response);
            }
            else if (realm.IsPrivate && realm.ApplicationUserId != userId)
            {
                response.ErrorMessages.Add($"Realm(code: {realm.Code}) is a private realm.");
                return(response);
            }

            _mapper.Map(request, realm);

            if (string.IsNullOrEmpty(realm.Name))
            {
                response.ErrorMessages.Add("Name is required.");
                return(response);
            }

            // Update tags
            var oldTagIds = request.TagList
                            .Where(x => x.Id.HasValue)
                            .Select(x => x.Id.Value);

            var currentTags = realm.Tags.ToList();

            foreach (var t in currentTags)
            {
                if (!oldTagIds.Contains(t.Id))
                {
                    realm.Tags.Remove(t);
                }
            }

            await ProcessAndPersistNewTags(realm, request.TagList);

            var shardResponse = ProcessAndPersistRealmShards(realm, request.Shards);

            if (!shardResponse.Success)
            {
                return(shardResponse);
            }

            // Save and return
            _realmDataService.SetToPersist(realm);
            await _realmDataService.SaveAsync();

            response.Data = _mapper.Map <RealmItemViewModel>(realm);
            return(response);
        }
Example #3
0
 public async Task <RealmUpdateResponse> Update(RealmUpdateRequest request)
 {
     return(await _realmService.UpdateRealm(User, request));
 }