public async Task <bool> Evalute(string projectId, Evalution evalution)
        {
            var EvaluatedProject = await _NoDb.FindAsync(projectId, projectId);

            EvaluatedProject.Evalution = evalution;
            var result = await _NoDb.UpdateAsync(EvaluatedProject);

            return(result.IsSuccess);
        }
        public async Task <bool> UpdateProject(string projectId, CosmosProjectDto updatedProject)
        {
            var oldProject = await _NoDb.FindAsync(projectId, projectId);

            if (oldProject != null)
            {
                oldProject.ProjectName = updatedProject.ProjectName;
                var result = await _NoDb.UpdateAsync(oldProject);

                return(result.IsSuccess);
            }
            return(false);
        }
Exemplo n.º 3
0
        public async Task UpdateAsync(UserFlatForRentAnnouncementPreferenceUpdatedIntegrationEvent integrationEvent)
        {
            var flatForRentAnnouncementPreference = await _cosmosStore.FindAsync(integrationEvent.FlatForRentAnnouncementPreferenceId.ToString());

            var sameCityDistricts = flatForRentAnnouncementPreference.CityDistricts.All(integrationEvent.CityDistricts.Contains) &&
                                    flatForRentAnnouncementPreference.CityDistricts.Count == integrationEvent.CityDistricts.Count;

            if (flatForRentAnnouncementPreference.CityId != integrationEvent.CityId ||
                flatForRentAnnouncementPreference.PriceMin != integrationEvent.PriceMin ||
                flatForRentAnnouncementPreference.PriceMax != integrationEvent.PriceMax ||
                flatForRentAnnouncementPreference.RoomNumbersMin != integrationEvent.RoomNumbersMin ||
                flatForRentAnnouncementPreference.RoomNumbersMax != integrationEvent.RoomNumbersMax ||
                !sameCityDistricts)
            {
                flatForRentAnnouncementPreference.AnnouncementUrlsToSend = new List <string>();
            }

            flatForRentAnnouncementPreference.CityId         = integrationEvent.CityId;
            flatForRentAnnouncementPreference.PriceMin       = integrationEvent.PriceMin;
            flatForRentAnnouncementPreference.PriceMax       = integrationEvent.PriceMax;
            flatForRentAnnouncementPreference.RoomNumbersMin = integrationEvent.RoomNumbersMin;
            flatForRentAnnouncementPreference.RoomNumbersMax = integrationEvent.RoomNumbersMax;
            flatForRentAnnouncementPreference.CityDistricts  = integrationEvent.CityDistricts.ToList();

            var updateResult = await _cosmosStore.UpdateAsync(flatForRentAnnouncementPreference);

            if (!updateResult.IsSuccess)
            {
                throw updateResult.Exception;
            }
        }
Exemplo n.º 4
0
        public async Task <bool> UpdatePostAsync(Post postToUpdate)
        {
            var response = await _cosmosStore.UpdateAsync(new CosmosPostDto
                                                          { Id = postToUpdate.Id.ToString(), Name = postToUpdate.Name });

            return(response.IsSuccess);
        }
Exemplo n.º 5
0
        public Task UpdateAsync(RoomForRentAnnouncement roomForRentAnnouncement)
        {
            var roomForRentAnnouncementEntity =
                _mapper.Map <RoomForRentAnnouncement, RoomForRentAnnouncementEntity>(roomForRentAnnouncement);

            return(_cosmosStore.UpdateAsync(roomForRentAnnouncementEntity));
        }
Exemplo n.º 6
0
        public Task UpdateAsync(FlatForRentAnnouncement flatForRentAnnouncement)
        {
            var flatForRentAnnouncementEntity =
                _mapper.Map <FlatForRentAnnouncement, FlatForRentAnnouncementEntity>(flatForRentAnnouncement);

            return(_cosmosStore.UpdateAsync(flatForRentAnnouncementEntity));
        }
Exemplo n.º 7
0
        public async Task UpdateAsync(UserRoomForRentAnnouncementPreferenceUpdatedIntegrationEvent integrationEvent)
        {
            var roomForRentAnnouncementPreference = await _cosmosStore.FindAsync(integrationEvent.RoomForRentAnnouncementPreferenceId.ToString());

            var sameCityDistricts = roomForRentAnnouncementPreference.CityDistricts.All(integrationEvent.CityDistricts.Contains) &&
                                    roomForRentAnnouncementPreference.CityDistricts.Count == integrationEvent.CityDistricts.Count;

            if (roomForRentAnnouncementPreference.CityId != integrationEvent.CityId ||
                roomForRentAnnouncementPreference.PriceMin != integrationEvent.PriceMin ||
                roomForRentAnnouncementPreference.PriceMax != integrationEvent.PriceMax ||
                roomForRentAnnouncementPreference.RoomType != integrationEvent.RoomType ||
                !sameCityDistricts)
            {
                roomForRentAnnouncementPreference.AnnouncementUrlsToSend = new List <string>();
            }

            roomForRentAnnouncementPreference.CityId        = integrationEvent.CityId;
            roomForRentAnnouncementPreference.PriceMin      = integrationEvent.PriceMin;
            roomForRentAnnouncementPreference.PriceMax      = integrationEvent.PriceMax;
            roomForRentAnnouncementPreference.RoomType      = integrationEvent.RoomType;
            roomForRentAnnouncementPreference.CityDistricts = integrationEvent.CityDistricts.ToList();

            var updateResult = await _cosmosStore.UpdateAsync(roomForRentAnnouncementPreference);

            if (!updateResult.IsSuccess)
            {
                throw updateResult.Exception;
            }
        }
Exemplo n.º 8
0
        public async Task <bool> UpdatePost(Post updatedPost)
        {
            var post = await cosmosStore.Query().FirstOrDefaultAsync(p => p.Id == updatedPost.Id.ToString());

            post.Name = updatedPost.Name;
            var response = await cosmosStore.UpdateAsync(post);

            return(response.IsSuccess);
        }
        public async Task ExecuteAsync(MarkProcessAsSuccessfulCommand command)
        {
            var process = await _cosmosStore.FindAsync(command.Id);

            process.EndDateTime = command.EndDateTime;
            process.Status      = ProcessStatus.Succeeded;

            await _cosmosStore.UpdateAsync(process);
        }
Exemplo n.º 10
0
        public async Task <ReportTemplate> Put(string id, ReportTemplate reportTemplate, VerifiedUserContext verifiedUser)
        {
            var templateToPut = await _store.Query().FirstOrDefaultAsync(template => template.TemplateID == id);

            reportTemplate.id = templateToPut.id;
            var updatedTemplate = await _store.UpdateAsync(reportTemplate);

            return(updatedTemplate);
        }
Exemplo n.º 11
0
        public async Task <ReportTemplate> Put(string id, ReportTemplate reportTemplate, DecodedToken decodedToken)
        {
            var templateToPut = await _store.Query().FirstOrDefaultAsync(template => template.TemplateID == id);

            reportTemplate.id = templateToPut.id;
            var updatedTemplate = await _store.UpdateAsync(reportTemplate);

            return(updatedTemplate);
        }
Exemplo n.º 12
0
        public async Task <bool> UpdatePostAsync(Post updatedPost)
        {
            var cosmosPost = new CosmosPost {
                Id = updatedPost.Id.ToString(), Name = updatedPost.Name
            };
            var response = await _CosmosStore.UpdateAsync(cosmosPost);

            return(response.IsSuccess);
        }
Exemplo n.º 13
0
        public async Task UpdateFamily(string id, string lastName)
        {
            var family = await GetSingleFamily(id);

            if (family != null)
            {
                family.LastName = lastName;
                await store.UpdateAsync(family);
            }
        }
Exemplo n.º 14
0
        public async Task <TodoItem> Update(TodoItem entity)
        {
            if (string.IsNullOrEmpty(entity.Title) && string.IsNullOrEmpty(entity.Description) && string.IsNullOrEmpty(entity.AssignedUserId))
            {
                throw new BadRequestException(ErrorCode.ValidationErrorGeneric);
            }
            entity = await CompareObjectForUpdate(entity);

            entity.LastModified = DateTime.UtcNow;
            return(await store.UpdateAsync(entity));
        }
Exemplo n.º 15
0
        public async Task <bool> UpdatePostAsync(Post postToUpdate)
        {
            var updatepost = new CosmosPostDto
            {
                Id   = postToUpdate.ID.ToString(),
                Name = postToUpdate.Name
            };
            var update = await _cosmosStore.UpdateAsync(updatepost);

            return(update.IsSuccess);
        }
Exemplo n.º 16
0
        public async Task <bool> UpdatePost(Post postToUpdate)
        {
            var cosmosPost = new CosmosPostDTO
            {
                Id   = postToUpdate.Id.ToString(),
                Name = postToUpdate.Name
            };
            var result = await _cosmosStore.UpdateAsync(cosmosPost);

            return(result.IsSuccess);
        }
Exemplo n.º 17
0
        public async Task <IActionResult> UpdateCrypto([FromForm] CryptoViewModel cryptoToUpdate)
        {
            if (cryptoToUpdate.valueUSD != null)
            {
                cryptoToUpdate.valueBTC = (double.Parse(cryptoToUpdate.valueUSD) / 7000).ToString();
                cryptoToUpdate.valueETH = (double.Parse(cryptoToUpdate.valueUSD) / 283).ToString();
            }

            var result = await _cosmosStore.UpdateAsync(cryptoToUpdate);

            return(RedirectToAction("Index"));
        }
Exemplo n.º 18
0
        public async Task <bool> UpdateMessageAsync(Message message)
        {
            var messageCosmos = new MessageCosmos
            {
                Id   = message.Id.ToString(),
                Text = message.Text
            };

            var response = await _cosmosStore.UpdateAsync(messageCosmos);

            return(response.IsSuccess);
        }
Exemplo n.º 19
0
        public async Task <bool> UpdateOrderAsync(Order orderToUpdate)
        {
            var cosmosOrder = new CosmosOrderDto
            {
                Id     = orderToUpdate.Id.ToString(),
                Amount = orderToUpdate.Amount
            };

            var response = await _cosmosStore.UpdateAsync(cosmosOrder);

            return(response.IsSuccess);
        }
Exemplo n.º 20
0
        public async Task <bool> UpdateAsync(Post post)
        {
            var cosmosPostDto = new CosmosPostDto
            {
                Id   = post.Id.ToString(),
                Name = post.Name
            };

            var updated = await _cosmosStore.UpdateAsync(cosmosPostDto);

            return(updated.IsSuccess);
        }
Exemplo n.º 21
0
        public async Task <bool> UpdateCustomTaskAsync(CustomTask customTaskToUpdate)
        {
            var cosmosCustomTask = new CosmosCustomTaskDto
            {
                Title       = customTaskToUpdate.Title,
                Description = customTaskToUpdate.Description
            };

            var response = await _cosmosStore.UpdateAsync(cosmosCustomTask);

            return(response.IsSuccess);
        }
Exemplo n.º 22
0
        public async Task <bool> UpdateArtist(Artist artist, string partitionKey)
        {
            var art = GetArtist(partitionKey);

            if (artist != null)
            {
                artist.PartitionKey = partitionKey;
                await Store.UpdateAsync(artist);

                return(true);
            }
            return(false);
        }
Exemplo n.º 23
0
        public async Task <bool> UpdateProductAsync(Product product)
        {
            var productCosmos = new CosmosProduct
            {
                ProductID   = product.ProductID.ToString(),
                ProductName = product.ProductName,
                ProductCode = product.ProductCode
            };

            var response = await _cosmosStore.UpdateAsync(productCosmos);

            return(response.IsSuccess);
        }
Exemplo n.º 24
0
        public async Task ExecuteAsync(MarkProcessAsFailedCommand command)
        {
            var process = await _cosmosStore.FindAsync(command.Id);

            process.EndDateTime    = command.EndDateTime;
            process.Status         = ProcessStatus.Failed;
            process.FailureDetails = new FailureDetails()
            {
                ErrorNumber  = command.ErrorNumber,
                ErrorMessage = command.ErrorMessage
            };

            await _cosmosStore.UpdateAsync(process);
        }
Exemplo n.º 25
0
        public async Task <User> Update(User entity)
        {
            if (string.IsNullOrEmpty(entity.Password))
            {
                var current = await Fetch(entity.Id);

                entity.Password = current.Password;
            }
            CosmosResponse <User> response = await store.UpdateAsync(entity);

            if (!response.IsSuccess && response.CosmosOperationStatus == CosmosOperationStatus.ResourceNotFound)
            {
                throw new NotFoundException(ErrorCode.NotFoundErrorGeneric, "Resource not found");
            }
            return(response);
        }
Exemplo n.º 26
0
        public async Task <T> Put(T update)
        {
            var time = DateTime.Now;

            update.DateLastUpdated = new DateTime(time.Year, time.Month, time.Day, 0, 0, 0);
            var resourceToUpdate = (await List(update.ResourceID)).FirstOrDefault(record => record.ResourceID == update.ResourceID && record.DateLastUpdated == update.DateLastUpdated);

            try
            {
                update.id     = resourceToUpdate.id;
                update.Action = resourceToUpdate.Action;
                return(await _productStore.UpdateAsync(update));
            }
            catch
            {
                return(await _productStore.AddAsync(update));
            }
        }
Exemplo n.º 27
0
        public async Task <bool> UpdatePostAsync(Post postToUpdate)
        {
            var post = await cosmosStore.FindAsync(postToUpdate.Id.ToString());

            if (post == null)
            {
                return(false);
            }

            var cosmposPost = new CosmosPostDto()
            {
                Id   = postToUpdate.Id.ToString(),
                Name = postToUpdate.Name
            };

            var response = await cosmosStore.UpdateAsync(cosmposPost);

            return(response.IsSuccess);
        }
Exemplo n.º 28
0
        public async Task <string> Handle(UpdateEbatchSheetCommand request, CancellationToken cancellationToken)
        {
            _logger.LogInformation(nameof(UpdateEbatchSheetCommandHandler) + "UPDATE_EBATCHSHEET: {requestId} - {@BODY} ", request.Id, request);

            var ebatchSheet = await _cosmosStore.FindAsync(request.Id, Constants.EBATCH_SHEET_PARTITON_KEY);

            var user = _httpContext.HttpContext?.User;

            if (ebatchSheet != null)
            {
                var currentState   = ebatchSheet.CurrentState;
                var requestedState = request.CurrentState;

                ebatchSheet.UpdateDataWithoutChangingState(request);

                if (!requestedState.Equals(currentState))
                {
                    if (user.IsInRole(UserRole.AdminTeam))
                    {
                        ebatchSheet.ChangeState(requestedState);
                    }
                    else
                    {
                        ebatchSheet.ProceedNextState(requestedState);
                    }
                }

                var result = await _cosmosStore.UpdateAsync(ebatchSheet);

                if (!currentState.Equals(result.Entity.CurrentState))
                {
                    await _ebatchSheetEmailSender.SendEmail(ebatchSheet);
                }
                return(request.Id);
            }
            else
            {
                var exception = new NotFoundException($"EBATCHSHEET", request.Id);
                _logger.LogError(exception, $"[UpdateEbatchSheetCommandHandler] Ebatchsheet {request.Id} not found");
                throw exception;
            }
        }
        public async Task <IActionResult> Update(
            Guid id, [FromBody] EditIndexRequest request, CancellationToken cancellationToken)
        {
            if (id == Guid.Empty)
            {
                return(BadRequest("Invalid index Id"));
            }

            if (request.Name.Trim().Length == 0)
            {
                return(BadRequest("Index Name can not be empty"));
            }

            var existingIndex = await _indexCosmosStore.FindAsync(id.ToString());

            if (existingIndex == null)
            {
                return(NotFound());
            }

            var indexToSave = new Index
            {
                Id       = id.ToString(),
                Name     = request.Name,
                Location = request.Location,
                Enabled  = request.Enabled
            };

            var result = await _indexCosmosStore.UpdateAsync(indexToSave);

            var indexId = result.Entity.Id;

            if (indexId == null)
            {
                return(BadRequest());
            }

            return(Ok(indexId));
        }
        public async Task <IActionResult> Update(Guid id, [FromBody] EditPersonRequest request,
                                                 CancellationToken cancellationToken)
        {
            if (id == Guid.Empty)
            {
                return(BadRequest("Invalid Person Id"));
            }

            if (request.Name.Trim().Length == 0)
            {
                return(BadRequest("Person Name can not be empty"));
            }

            var existingPerson =
                await _peopleCosmosStore.FindAsync(id.ToString(), cancellationToken : cancellationToken);

            if (existingPerson == null)
            {
                return(NotFound());
            }

            var personToSave = new Person
            {
                Id   = id.ToString(),
                Name = request.Name
            };

            var result = await _peopleCosmosStore.UpdateAsync(personToSave, cancellationToken : cancellationToken);

            var personId = result.Entity.Id;

            if (personId == null)
            {
                return(BadRequest());
            }

            return(Ok(personId));
        }