Example #1
0
        public async Task UpdateCompanyAsync_ValidUpdate_ShouldReturnUpdatedCompany()
        {
            // Arrange
            await this.fixture.ClearFactroInstanceAsync();

            var companyApi = this.fixture.GetService <ICompanyApi>();

            var existingCompany = await this.fixture.CreateTestCompanyAsync(companyApi);

            var updatedName          = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}";
            var updateCompanyRequest = new UpdateCompanyRequest
            {
                Name = updatedName,
            };

            var updateCompanyResponse = new UpdateCompanyResponse();

            // Act
            Func <Task> act = async() => updateCompanyResponse = await companyApi.UpdateCompanyAsync(existingCompany.Id, updateCompanyRequest);

            // Assert
            await act.Should().NotThrowAsync();

            using (new AssertionScope())
            {
                var companies = (await companyApi.GetCompaniesAsync())
                                .Where(x => x.Name.StartsWith(BaseTestFixture.TestPrefix)).ToList();

                companies.Should().ContainEquivalentOf(updateCompanyResponse);

                companies.Single(x => x.Id == existingCompany.Id).Name.Should().Be(updatedName);
            }

            await this.fixture.ClearFactroInstanceAsync();
        }
        public void UpdateCompany()
        {
            moq::Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new moq::Mock <CompanyService.CompanyServiceClient>(moq::MockBehavior.Strict);
            UpdateCompanyRequest request = new UpdateCompanyRequest
            {
                Company = new Company(),
            };
            Company expectedResponse = new Company
            {
                CompanyName         = CompanyName.FromProjectTenantCompany("[PROJECT]", "[TENANT]", "[COMPANY]"),
                DisplayName         = "display_name137f65c2",
                ExternalId          = "external_id9442680e",
                Size                = CompanySize.Mini,
                HeadquartersAddress = "headquarters_address64cd7eb7",
                HiringAgency        = true,
                EeoText             = "eeo_text70a1a576",
                WebsiteUri          = "website_urid0c5dfce",
                CareerSiteUri       = "career_site_uri62d45b74",
                ImageUri            = "image_urieba3b1bc",
                KeywordSearchableJobCustomAttributes =
                {
                    "keyword_searchable_job_custom_attributese72ec77c",
                },
                DerivedInfo = new Company.Types.DerivedInfo(),
                Suspended   = true,
            };

            mockGrpcClient.Setup(x => x.UpdateCompany(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            Company response            = client.UpdateCompany(request.Company);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Example #3
0
        public async Task UpdateCompanyAsync_NotExistingCompanyId_ShouldThrowFactroApiException()
        {
            // Arrange
            await this.fixture.ClearFactroInstanceAsync();

            var companyApi = this.fixture.GetService <ICompanyApi>();

            var updatedName          = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}";
            var updateCompanyRequest = new UpdateCompanyRequest
            {
                Name = updatedName,
            };

            var updateCompanyResponse = default(UpdateCompanyResponse);

            // Act
            Func <Task> act = async() => updateCompanyResponse = await companyApi.UpdateCompanyAsync(Guid.NewGuid().ToString(), updateCompanyRequest);

            // Assert
            await act.Should().ThrowAsync <FactroApiException>();

            using (new AssertionScope())
            {
                var companies = (await companyApi.GetCompaniesAsync())
                                .Where(x => x.Name.StartsWith(BaseTestFixture.TestPrefix)).ToList();

                companies.All(x => x.Name != updatedName).Should().BeTrue();

                updateCompanyResponse.Should().BeNull();
            }

            await this.fixture.ClearFactroInstanceAsync();
        }
Example #4
0
        public async Task <IActionResult> UpdateCompanyInfo([FromBody] UpdateCompanyRequest company)
        {
            company.Email = User.Identity.Name;
            await _companyBusinessLogic.UpdateCompany(company);

            return(this.OkResult());
        }
Example #5
0
        public void UpdateCompany2()
        {
            Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
            UpdateCompanyRequest request = new UpdateCompanyRequest
            {
                Company = new Company(),
            };
            Company expectedResponse = new Company
            {
                Name                = "name3373707",
                DisplayName         = "displayName1615086568",
                ExternalId          = "externalId-1153075697",
                HeadquartersAddress = "headquartersAddress-1879520036",
                HiringAgency        = false,
                EeoText             = "eeoText-1652097123",
                WebsiteUri          = "websiteUri-2118185016",
                CareerSiteUri       = "careerSiteUri1223331861",
                ImageUri            = "imageUri-877823864",
                Suspended           = false,
            };

            mockGrpcClient.Setup(x => x.UpdateCompany(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            Company response            = client.UpdateCompany(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Example #6
0
        public async Task UpdateCompanyAsync2()
        {
            Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
            UpdateCompanyRequest request = new UpdateCompanyRequest
            {
                Company = new Company(),
            };
            Company expectedResponse = new Company
            {
                CompanyNameOneof    = CompanyNameOneof.From(new CompanyOldName("[PROJECT]", "[COMPANY]")),
                DisplayName         = "displayName1615086568",
                ExternalId          = "externalId-1153075697",
                HeadquartersAddress = "headquartersAddress-1879520036",
                HiringAgency        = false,
                EeoText             = "eeoText-1652097123",
                WebsiteUri          = "websiteUri-2118185016",
                CareerSiteUri       = "careerSiteUri1223331861",
                ImageUri            = "imageUri-877823864",
                Suspended           = false,
            };

            mockGrpcClient.Setup(x => x.UpdateCompanyAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <Company>(Task.FromResult(expectedResponse), null, null, null, null));
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            Company response            = await client.UpdateCompanyAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Example #7
0
        public async Task UpdateCompanyAsync_InvalidUpdate_ShouldNotUpdateCompany()
        {
            // Arrange
            await this.fixture.ClearFactroInstanceAsync();

            var companyApi = this.fixture.GetService <ICompanyApi>();

            var existingCompany = await this.fixture.CreateTestCompanyAsync(companyApi);

            const string updatedName          = null;
            var          updateCompanyRequest = new UpdateCompanyRequest
            {
                Name = updatedName,
            };

            // Act
            Func <Task> act = async() => await companyApi.UpdateCompanyAsync(existingCompany.Id, updateCompanyRequest);

            // Assert
            await act.Should().NotThrowAsync();

            using (new AssertionScope())
            {
                var companies = (await companyApi.GetCompaniesAsync())
                                .Where(x => x.Name.StartsWith(BaseTestFixture.TestPrefix)).ToList();

                companies.Single(x => x.Id == existingCompany.Id).Should().BeEquivalentTo(existingCompany);
            }

            await this.fixture.ClearFactroInstanceAsync();
        }
Example #8
0
        public async Task <bool> Handle(UpdateCompanyRequest message, IOutputPort <UpdateCompanyResponse> outputPort)
        {
            var response = await _companyRepository.Update(message.Id,
                                                           new Domain.Entities.Company(message.CompanyName, message.YearEstablished, message.Employees));

            outputPort.Handle(response.Success ? new UpdateCompanyResponse(true) : new UpdateCompanyResponse(response.Errors));
            return(response.Success);
        }
Example #9
0
        public static Task <UpdateCompanyResponse> UpdateCompanyResponseAsync(Company company, IEndpointInstance endpointInstance)

        {
            var message     = new UpdateCompanyRequest(company);
            var sendOptions = new SendOptions();

            sendOptions.SetDestination("NServiceBusCore.Server");
            var responseTask = endpointInstance
                               .Request <UpdateCompanyResponse>(message, sendOptions);

            return(responseTask);
        }
Example #10
0
        public async Task <ActionResult <string> > Update([FromBody] UpdateCompanyRequest request)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            return(new JsonResult(
                       Mapper.Map <CompanyViewModel>(
                           await CompanyService.UpdateCompanyAsync(
                               Mapper.Map <Company>(request)))));
        }
Example #11
0
        public async Task UpdateCompanyAsync_InvalidCompanyId_ShouldThrowArgumentNullException(string companyId)
        {
            // Arrange
            var companyApi = this.fixture.GetCompanyApi();

            var updateCompanyRequest = new UpdateCompanyRequest();

            // Act
            Func <Task> act = async() => await companyApi.UpdateCompanyAsync(companyId, updateCompanyRequest);

            // Assert
            await act.Should().ThrowAsync <ArgumentNullException>();
        }
Example #12
0
        /// <inheritdoc />
        public async Task <Company> UpdateCompanyAsync(
            long companyId,
            UpdateCompanyRequest request,
            CancellationToken cancellationToken = default)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request), "Request must not be null");
            }

            return(await _freshdeskClient
                   .ApiOperationAsync <Company, UpdateCompanyRequest>(HttpMethod.Put, $"/api/v2/companies/{companyId}", request, cancellationToken)
                   .ConfigureAwait(false));
        }
 /// <summary>Snippet for UpdateCompany</summary>
 public void UpdateCompany_RequestObject()
 {
     // Snippet: UpdateCompany(UpdateCompanyRequest,CallSettings)
     // Create client
     CompanyServiceClient companyServiceClient = CompanyServiceClient.Create();
     // Initialize request argument(s)
     UpdateCompanyRequest request = new UpdateCompanyRequest
     {
         Company = new Company(),
     };
     // Make the request
     Company response = companyServiceClient.UpdateCompany(request);
     // End snippet
 }
Example #14
0
    private string UpdateCompany()
    {
        string msg = "";
        ServiceManager sm = new ServiceManager();
        using (LP2ServiceClient service = sm.StartServiceClient())
        {
            UpdateCompanyRequest req = new UpdateCompanyRequest();
            req.hdr = new ReqHdr();
            req.hdr.SecurityToken = "SecurityToken"; //todo:check dummy data
            if (CurrUser != null)
            {
                req.hdr.UserId = this.CurrUser.iUserID;
            }

            UpdateCompanyResponse respone = null;
            try
            {
                respone = service.UpdateCompany(req);

                if (respone.hdr.Successful)
                {
                    msg = "Saved successfully.";
                    return msg;
                }
                else
                {
                    if (respone.hdr.StatusInfo == "")
                        respone.hdr.StatusInfo = " Marketing Manager is not running.";
                    msg = "Failed to update company, reason:" + respone.hdr.StatusInfo;
                    return msg;
                }
            }
            catch (System.ServiceModel.EndpointNotFoundException ee)
            {
                LPLog.LogMessage(ee.Message);
                msg = "Failed to update copmany , reason: Marketing Manager is not running.";
                return msg;
            }
            catch (Exception exception)
            {
                LPLog.LogMessage(exception.Message);
                msg = "Failed to update company, reason:" + exception.Message;
                return msg;
            }
        }

    }
        /// <summary>Snippet for UpdateCompanyAsync</summary>
        public async Task UpdateCompanyAsync_RequestObject()
        {
            // Snippet: UpdateCompanyAsync(UpdateCompanyRequest,CallSettings)
            // Additional: UpdateCompanyAsync(UpdateCompanyRequest,CancellationToken)
            // Create client
            CompanyServiceClient companyServiceClient = await CompanyServiceClient.CreateAsync();

            // Initialize request argument(s)
            UpdateCompanyRequest request = new UpdateCompanyRequest
            {
                Company = new Company(),
            };
            // Make the request
            Company response = await companyServiceClient.UpdateCompanyAsync(request);

            // End snippet
        }
        // [END get_company]

        // [START update_company]

        public static Company UpdateCompany(String companyName, Company companyToBeUpdated)
        {
            try
            {
                UpdateCompanyRequest updateCompanyRequest = new UpdateCompanyRequest()
                {
                    Company = companyToBeUpdated
                };
                Company companyUpdated = jobServiceClient.Projects.Companies.Patch(updateCompanyRequest, companyName).Execute();
                Console.WriteLine("Company updated: " + ToJsonString(companyUpdated));
                return(companyUpdated);
            }
            catch (Exception e)
            {
                Console.WriteLine("Got exception while updating company");
                throw e;
            }
        }
Example #17
0
        public async Task UpdateCompanyAsync_ValidRequest_ShouldReturnUpdatedCompany()
        {
            // Arrange
            var existingCompany = new GetCompanyPayload
            {
                Id   = Guid.NewGuid().ToString(),
                Name = "TestName",
            };

            var updateCompanyRequest = new UpdateCompanyRequest
            {
                Name = "NewName",
            };

            var expectedUpdatedCompany = new UpdateCompanyResponse
            {
                Id   = existingCompany.Id,
                Name = updateCompanyRequest.Name,
            };

            var expectedResponseContent = new StringContent(JsonConvert.SerializeObject(expectedUpdatedCompany, this.fixture.JsonSerializerSettings));

            var expectedResponse = new HttpResponseMessage
            {
                Content = expectedResponseContent,
            };

            var companyApi = this.fixture.GetCompanyApi(expectedResponse);

            var updateCompanyResponse = new UpdateCompanyResponse();

            // Act
            Func <Task> act = async() =>
                              updateCompanyResponse = await companyApi.UpdateCompanyAsync(existingCompany.Id, updateCompanyRequest);

            // Assert
            await act.Should().NotThrowAsync();

            using (new AssertionScope())
            {
                updateCompanyResponse.Id.Should().Be(existingCompany.Id);
                updateCompanyResponse.Name.Should().Be(expectedUpdatedCompany.Name);
            }
        }
Example #18
0
        public async Task <IActionResult> UpdateAsync([FromRoute] int companyId, [FromBody] UpdateCompanyRequest request)
        {
            Company company = (await _companyService.GetAsync(x => x.Id == companyId)).FirstOrDefault();

            if (company == null)
            {
                return(NotFound(new NotFoundObjectResult($"There is no Company with Id {companyId}. Please try with another CompanyId")));
            }

            company.Name = request.Name;

            var updated = await _companyService.UpdateAsync(company);

            if (!updated)
            {
                return(NotFound(new NotFoundObjectResult($"Company was not updated.")));
            }

            return(Ok(new Response <CompanyResponse>(_mapper.Map <CompanyResponse>(company))));
        }
Example #19
0
        public IHttpActionResult PutCompany(int id, UpdateCompanyRequest companyRequest)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var existingCompany = _companyService.Get(id);

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

            existingCompany.Name = companyRequest.Name;
            existingCompany.Tva  = companyRequest.Tva;

            _companyService.Update(existingCompany);
            return(StatusCode(HttpStatusCode.NoContent));
        }
Example #20
0
        public bool Update(Company el)
        {
            IRequest request = new UpdateCompanyRequest(el);

            try
            {
                using (var connection = new SqlConnection(connectionString))
                {
                    connection.Open();
                    using (var transaction = connection.BeginTransaction())
                    {
                        connection.Execute(request.Sql, transaction: transaction);
                        transaction.Commit();
                    }
                }
                return(true);
            }
            catch (Exception e)
            {
                return(false);
            }
        }
Example #21
0
        public async stt::Task UpdateCompanyRequestObjectAsync()
        {
            moq::Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new moq::Mock <CompanyService.CompanyServiceClient>(moq::MockBehavior.Strict);
            UpdateCompanyRequest request = new UpdateCompanyRequest
            {
                Company    = new Company(),
                UpdateMask = new wkt::FieldMask(),
            };
            Company expectedResponse = new Company
            {
                CompanyName         = CompanyName.FromProjectCompany("[PROJECT]", "[COMPANY]"),
                DisplayName         = "display_name137f65c2",
                ExternalId          = "external_id9442680e",
                Size                = CompanySize.Mini,
                HeadquartersAddress = "headquarters_address64cd7eb7",
                HiringAgency        = true,
                EeoText             = "eeo_text70a1a576",
                WebsiteUri          = "website_urid0c5dfce",
                CareerSiteUri       = "career_site_uri62d45b74",
                ImageUri            = "image_urieba3b1bc",
                KeywordSearchableJobCustomAttributes =
                {
                    "keyword_searchable_job_custom_attributese72ec77c",
                },
                DerivedInfo = new Company.Types.DerivedInfo(),
                Suspended   = true,
            };

            mockGrpcClient.Setup(x => x.UpdateCompanyAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Company>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            CompanyServiceClient client  = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            Company responseCallSettings = await client.UpdateCompanyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Company responseCancellationToken = await client.UpdateCompanyAsync(request, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Example #22
0
        // PUT api/companies/5
        public HttpResponseMessage Put(string id, [FromBody] UpdateCompanyRequest values)
        {
            if (!ModelState.IsValid)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest)
                {
                    Content = new StringContent("The company data contains some invalid data. Please correct for errors and try again.")
                });
            }

            var parameters = _identityProvider.SetUserIdentity(values.Map().To <UpdateCompanyParameters>());

            parameters.CompanyKey = id;

            var result = _companyService.UpdateCompany(parameters);

            result.EnsureSuccessWithHttpResponseException(HttpVerbs.Put);

            return(new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = Get(id).ToJSONContent()
            });
        }
Example #23
0
        public async Task UpdateCompanyAsync_UnsuccessfulRequest_ShouldThrowCompanyApiException()
        {
            // Arrange
            var companyId            = Guid.NewGuid().ToString();
            var updateCompanyRequest = new UpdateCompanyRequest();

            var expectedResponse = new HttpResponseMessage
            {
                StatusCode     = HttpStatusCode.BadRequest,
                RequestMessage = new HttpRequestMessage
                {
                    RequestUri = new Uri("http://www.mock-web-address.com"),
                },
            };

            var companyApi = this.fixture.GetCompanyApi(expectedResponse);

            // Act
            Func <Task> act = async() => await companyApi.UpdateCompanyAsync(companyId, updateCompanyRequest);

            // Assert
            await act.Should().ThrowAsync <FactroApiException>();
        }
Example #24
0
        public UpdateCompanyResponse UpdateCompany(UpdateCompanyRequest request)
        {
            UpdateCompanyResponse response = new UpdateCompanyResponse();
            response.ExceptionState = false;

            Company company = new Company();
            company.Id = request.Id;
            company.Name = request.Name.ToUpper(new CultureInfo("tr-TR"));
            company.Description = string.IsNullOrEmpty(request.Description) ? string.Empty : request.Description.ToUpper(new CultureInfo("tr-TR"));
            company.IsActive = request.IsActive;
            company.CompanyType = _companyTypeRepository.FindBy(request.CompanyTypeId);
            company.ParentCompany = _companyRepository.FindBy(request.ParentCompanyId ?? 0);

            Query query = new Query();

            if (company.ParentCompany == null)
            {
                query.Add(Criterion.Create<Company>(c => c.Id, company.Id, CriteriaOperator.NotEqual));
                query.Add(Criterion.Create<Company>(c => c.ParentCompany, null, CriteriaOperator.IsNull));

                if (_companyRepository.FindBy(query).Count() > 0)
                {
                    response.ExceptionState = true;
                    response.ExceptionMessage = @"Zaten bir ana firma var. Lütfen oluşturmaya çalıştığınız firmanın bağlı olduğu firmayı seçiniz.";

                    return response;
                }
            }

            if (company.Name != _companyRepository.FindBy(request.Id).Name)
            {
                query = new Query();
                query.Add(Criterion.Create<Company>(c => c.Name, company.Name, CriteriaOperator.Equal));
                if (_companyRepository.FindBy(query).Count() > 0)
                {
                    response.ExceptionState = true;
                    response.ExceptionMessage = @"Bu isimde bir firma zaten var. Lütfen firma adını benzersiz bir isim olarak düzenleyin.";

                    response.Company = company.ConvertToCompanyView();

                    return response;
                }
            }

            _companyRepository.Save(company);
            _unitOfWork.Commit();

            response.Company = company.ConvertToCompanyView();

            return response;
        }
Example #25
0
        public UpdateCompanyResponse UpdateCompany(UpdateCompanyRequest request)
        {
            Dictionary<string, string> data = new Dictionary<string, string>();
            data["id"] = request.Id.ToString();
            data["name"] = request.Name;
            data["address"] = request.Address;
            data["city"] = request.City;
            data["state"] = request.State;
            data["zip"] = request.Zip;
            data["phone1"] = request.Phone1;
            data["phone2"] = request.Phone2;
            data["url"] = request.Url;
            data["key_technologies"] = request.KeyTechnologies;
            data["notes"] = request.Notes;
            if (request.EnteredBy != -1)
            {
                data["entered_by"] = request.EnteredBy.ToString();
            }
            if (request.Owner != -1)
            {
                data["owner"] = request.Owner.ToString();
            }
            if (request.DateCreated != DateTime.MinValue)
            {
                data["date_created"] = DateTimeToUnixTimestamp(request.DateCreated);
            }
            if (request.DateModified != DateTime.MinValue)
            {
                data["date_modified"] = DateTimeToUnixTimestamp(request.DateModified);
            }
            if (request.IsHot != null)
            {
                data["is_hot"] = request.IsHot.ToString().ToLower();
            }
            data["fax_number"] = request.FaxNumber;
            if (request.Country != -1)
            {
                data["country"] = request.Country.ToString();
            }

            Dictionary<string, string> files = new Dictionary<string, string>();
            if (request.File != String.Empty)
            {
                files.Add("file", request.File);
            }

            UpdateCompanyResponse response = new UpdateCompanyResponse(
                MakeRequest("update_company", data, files)
            );
            return response;
        }
        public async Task <UpdateCompanyResponse> UpdateCompanyAsync(string companyId, UpdateCompanyRequest updateCompanyRequest)
        {
            if (string.IsNullOrWhiteSpace(companyId))
            {
                throw new ArgumentNullException(nameof(companyId), $"{nameof(companyId)} can not be null, empty or whitespace.");
            }

            if (updateCompanyRequest == null)
            {
                throw new ArgumentNullException(nameof(updateCompanyRequest), $"{nameof(updateCompanyRequest)} can not be null.");
            }

            var requestRoute = CompanyApiEndpoints.Base.Update(companyId);

            var requestString  = JsonConvert.SerializeObject(updateCompanyRequest, this.jsonSerializerSettings);
            var requestContent = ApiHelpers.GetStringContent(requestString);

            var response = await this.httpClient.PutAsync(requestRoute, requestContent);

            if (!response.IsSuccessStatusCode)
            {
                throw new FactroApiException(
                          $"Could not update company with id '{companyId}'.",
                          response.RequestMessage.RequestUri.ToString(),
                          response.StatusCode,
                          response.Content == null ? null : await response.Content.ReadAsStringAsync());
            }

            var responseContentString = await response.Content.ReadAsStringAsync();

            var result =
                JsonConvert.DeserializeObject <UpdateCompanyResponse>(
                    responseContentString,
                    this.jsonSerializerSettings);

            return(result);
        }
Example #27
0
 public async Task UpdateCompany(UpdateCompanyRequest company)
 {
     var companyModel = Mapper.Map <Company>(company);
     await _mongoDbRepository.Replace(companyModel);
 }