public async Task CreateCompany(CreateCompanyRequest company)
{
var companyModel = Mapper.Map <Company>(company);
companyModel.Id = IdGeneratorHelper.IdGenerator();
await _mongoDbRepository.Create(companyModel);
}
public async Task <bool> CreateCompany(CreateCompanyRequest createCompanyRequest)
{
//-- the result wheter or not the creation was successfull
bool resultProcess = false;
//-- checks if the company request is null
if (createCompanyRequest != null)
{
//-- new instance of a Company
var company = new Company()
{
CompanyName = createCompanyRequest.CompanyName,
CompanyBalance = 0,
Active = true
};
//-- Connecting to the database using the CompaniesEntities
using (var entitys = new CompanyBrokerCompaniesEntities())
{
//-- adds a new company to the Companies table
entitys.Companies.Add(company);
//-- Saves the changes to the database
await entitys.SaveChangesAsync();
//-- Sets the result process to true
resultProcess = true;
}
}
//-- returns the result
return(resultProcess);
}
public async Task <IActionResult> CreateCompanyInfo([FromBody] CreateCompanyRequest company)
{
company.Email = User.Identity.Name;
await _companyBusinessLogic.CreateCompany(company);
return(this.OkResult());
}
// [START job_search_create_company_beta]
public static object CreateCompany(string projectId, string tenantId, string displayName, string externalId)
{
CompanyServiceClient companyServiceClient = CompanyServiceClient.Create();
TenantName tenantName = new TenantName(projectId, tenantId);
TenantOrProjectNameOneof parent = TenantOrProjectNameOneof.From(tenantName);
Company company = new Company
{
DisplayName = displayName,
ExternalId = externalId
};
CreateCompanyRequest request = new CreateCompanyRequest
{
ParentAsTenantOrProjectNameOneof = parent,
Company = company
};
Company response = companyServiceClient.CreateCompany(request);
Console.WriteLine("Created Company");
Console.WriteLine($"Name: {response.Name}");
Console.WriteLine($"Display Name: {response.DisplayName}");
Console.WriteLine($"External ID: {response.ExternalId}");
return(0);
}
public async Task CreateCompanyAsync_ValidCompany_ShouldStoreCompany()
{
// Arrange
await this.fixture.ClearFactroInstanceAsync();
var companyApi = this.fixture.GetService <ICompanyApi>();
var name = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}";
var createCompanyRequest = new CreateCompanyRequest(name);
var createCompanyResponse = default(CreateCompanyResponse);
// Act
Func <Task> act = async() => createCompanyResponse = await companyApi.CreateCompanyAsync(createCompanyRequest);
// Assert
await act.Should().NotThrowAsync();
using (new AssertionScope())
{
var companies = (await companyApi.GetCompaniesAsync())
.Where(x => x.Name.StartsWith(BaseTestFixture.TestPrefix)).ToList();
companies.Should().ContainEquivalentOf(createCompanyResponse);
}
await this.fixture.ClearFactroInstanceAsync();
}
public async Task CreateCompany_ValidRequest_ShouldReturnExpectedCompany()
{
// Arrange
var createCompanyRequest = new CreateCompanyRequest(Guid.NewGuid().ToString());
var expectedCompany = new CreateCompanyResponse
{
Name = createCompanyRequest.Name,
};
var expectedResponseContent = new StringContent(JsonConvert.SerializeObject(expectedCompany, this.fixture.JsonSerializerSettings));
var expectedResponse = new HttpResponseMessage
{
Content = expectedResponseContent,
};
var companyApi = this.fixture.GetCompanyApi(expectedResponse);
var createCompanyResponse = default(CreateCompanyResponse);
// Act
Func <Task> act = async() => createCompanyResponse = await companyApi.CreateCompanyAsync(createCompanyRequest);
// Assert
await act.Should().NotThrowAsync();
createCompanyResponse.Should().BeEquivalentTo(expectedCompany);
}
public async Task CreateCompanyAsync_TwoCompaniesWithSameName_ShouldStoreBothCompanies()
{
// Arrange
await this.fixture.ClearFactroInstanceAsync();
var companyApi = this.fixture.GetService <ICompanyApi>();
var name = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}";
var createCompanyRequest = new CreateCompanyRequest(name);
var firstCreatedCompany = await companyApi.CreateCompanyAsync(createCompanyRequest);
var secondCreatedCompany = default(CreateCompanyResponse);
// Act
Func <Task> act = async() => secondCreatedCompany = await companyApi.CreateCompanyAsync(createCompanyRequest);
// Assert
await act.Should().NotThrowAsync();
using (new AssertionScope())
{
secondCreatedCompany.Should().NotBeNull();
var companies = (await companyApi.GetCompaniesAsync())
.Where(x => x.Name.StartsWith(BaseTestFixture.TestPrefix)).ToList();
companies.Should().Contain(x => x.Id == firstCreatedCompany.Id)
.And.Contain(x => x.Id == secondCreatedCompany.Id);
}
}
public async Task CreateCompanyAsync()
{
Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
CreateCompanyRequest expectedRequest = new CreateCompanyRequest
{
ParentAsTenantOrProjectNameOneof = TenantOrProjectNameOneof.From(new TenantName("[PROJECT]", "[TENANT]")),
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.CreateCompanyAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Company>(Task.FromResult(expectedResponse), null, null, null, null));
CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
TenantOrProjectNameOneof parent = TenantOrProjectNameOneof.From(new TenantName("[PROJECT]", "[TENANT]"));
Company company = new Company();
Company response = await client.CreateCompanyAsync(parent, company);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void CreateCompany()
{
Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
CreateCompanyRequest expectedRequest = new CreateCompanyRequest
{
Parent = new ProjectName("[PROJECT]").ToString(),
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.CreateCompany(expectedRequest, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
string formattedParent = new ProjectName("[PROJECT]").ToString();
Company company = new Company();
Company response = client.CreateCompany(formattedParent, company);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void CreateCompanyRequestObject()
{
moq::Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new moq::Mock <CompanyService.CompanyServiceClient>(moq::MockBehavior.Strict);
CreateCompanyRequest request = new CreateCompanyRequest
{
ParentAsTenantName = TenantName.FromProjectTenant("[PROJECT]", "[TENANT]"),
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.CreateCompany(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
Company response = client.CreateCompany(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <CreateCompanyResponse> CreateTestCompanyAsync(ICompanyApi companyApi)
{
var name = $"{TestPrefix}{Guid.NewGuid().ToString()}";
var createCompanyRequest = new CreateCompanyRequest(name);
var createCompanyResponse = await companyApi.CreateCompanyAsync(createCompanyRequest);
return(createCompanyResponse);
}
public static Task <CreateCompanyResponse> CreateCompanyResponseAsync(Company company, IEndpointInstance endpointInstance)
{
var message = new CreateCompanyRequest(company);
var sendOptions = new SendOptions();
sendOptions.SetDestination("NServiceBusCore.Server");
var responseTask = endpointInstance
.Request <CreateCompanyResponse>(message, sendOptions);
return(responseTask);
}
public static Company CreateCompany(Company companyToBeCreated)
{
// Start method
CreateCompanyRequest createCompanyRequest = new CreateCompanyRequest();
createCompanyRequest.Company = companyToBeCreated;
Company companyCreated = jobServiceClient.Projects.Companies.Create(createCompanyRequest, parent).Execute();
Console.WriteLine("Created company: " + ToJsonString(companyCreated));
return(companyCreated);
}
public async Task CreateCompanyAsync_NullRequestModelName_ShouldThrowArgumentNullException()
{
// Arrange
var createCompanyRequest = new CreateCompanyRequest(name: null);
var companyApi = this.fixture.GetCompanyApi();
// Act
Func <Task> act = async() => await companyApi.CreateCompanyAsync(createCompanyRequest);
// Assert
await act.Should().ThrowAsync <ArgumentNullException>();
}
/// <inheritdoc />
public async Task <Company> CreateCompanyAsync(
CreateCompanyRequest request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request), "Request must not be null");
}
return(await _freshdeskClient
.ApiOperationAsync <Company, CreateCompanyRequest>(HttpMethod.Post, $"/api/v2/companies", request, cancellationToken)
.ConfigureAwait(false));
}
/// <summary>Snippet for CreateCompany</summary>
public void CreateCompanyRequestObject()
{
// Snippet: CreateCompany(CreateCompanyRequest, CallSettings)
// Create client
CompanyServiceClient companyServiceClient = CompanyServiceClient.Create();
// Initialize request argument(s)
CreateCompanyRequest request = new CreateCompanyRequest
{
ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
Company = new Company(),
};
// Make the request
Company response = companyServiceClient.CreateCompany(request);
// End snippet
}
/// <summary>Snippet for CreateCompany</summary>
public void CreateCompany_RequestObject()
{
// Snippet: CreateCompany(CreateCompanyRequest,CallSettings)
// Create client
CompanyServiceClient companyServiceClient = CompanyServiceClient.Create();
// Initialize request argument(s)
CreateCompanyRequest request = new CreateCompanyRequest
{
ParentAsTenantOrProjectNameOneof = TenantOrProjectNameOneof.From(new TenantName("[PROJECT]", "[TENANT]")),
Company = new Company(),
};
// Make the request
Company response = companyServiceClient.CreateCompany(request);
// End snippet
}
// [START create_company]
public static Company CreateCompany(Company companyToBeCreated)
{
try
{
CreateCompanyRequest createCompanyRequest = new CreateCompanyRequest();
createCompanyRequest.Company = companyToBeCreated;
Company companyCreated = jobServiceClient.Projects.Companies.Create(createCompanyRequest, parent).Execute();
Console.WriteLine("Created company: " + ToJsonString(companyCreated));
return(companyCreated);
}
catch (Exception e)
{
Console.WriteLine("Got exception while creating company");
throw e;
}
}
public async Task <ActionResult <string> > Post([FromBody] CreateCompanyRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var companyToCreate = Mapper.Map <Company>(request);
companyToCreate.Owner = new User {
UserName = request.OwnerName
};
return(new JsonResult(
Mapper.Map <CompanyViewModel>(
await CompanyService.CreateCompanyAsync(companyToCreate))));
}
/// <summary>Snippet for CreateCompanyAsync</summary>
public async Task CreateCompanyAsync_RequestObject()
{
// Snippet: CreateCompanyAsync(CreateCompanyRequest,CallSettings)
// Additional: CreateCompanyAsync(CreateCompanyRequest,CancellationToken)
// Create client
CompanyServiceClient companyServiceClient = await CompanyServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCompanyRequest request = new CreateCompanyRequest
{
ParentAsTenantOrProjectNameOneof = TenantOrProjectNameOneof.From(new TenantName("[PROJECT]", "[TENANT]")),
Company = new Company(),
};
// Make the request
Company response = await companyServiceClient.CreateCompanyAsync(request);
// End snippet
}
// [START job_search_create_company_core]
/// <summary>
/// Create Company
/// </summary>
/// <param name="projectId">Your Google Cloud Project ID</param>
public static void SampleCreateCompany(string projectId, string displayName, string externalId)
{
CompanyServiceClient companyServiceClient = CompanyServiceClient.Create();
// string projectId = "Your Google Cloud Project ID"
// string displayName = "My Company Name"
// string externalId = "Identifier of this company in my system"
CreateCompanyRequest request = new CreateCompanyRequest
{
ParentAsTenantOrProjectNameOneof = TenantOrProjectNameOneof.From(new ProjectName(projectId)),
Company = new Company
{
DisplayName = "My Company Name",
ExternalId = "Identifier of this company in my system",
},
};
Company response = companyServiceClient.CreateCompany(request);
// FIXME: inspect the results
}
public async Task <IActionResult> CreateAsync([FromBody] CreateCompanyRequest request)
{
if (string.IsNullOrEmpty(request.Name) || request.Name.Length < 5)
{
return(BadRequest(new BadRequestObjectResult($"Name must have atleast 5 characters.")));
}
Company createdCompany = await _companyService.CreateAsync(_mapper.Map <Company>(request));
if (createdCompany == null)
{
return(NotFound(new NotFoundObjectResult($"Company was not created.")));
}
var locationUri = _uriService.GetCompanyUri(Request.Path.Value.Substring(1) + "/" + createdCompany.Id.ToString());
return(Created(locationUri, new Response <CompanyResponse>(_mapper.Map <CompanyResponse>(createdCompany))));
}
// POST api/companies
public HttpResponseMessage Post([FromBody] CreateCompanyRequest 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 <CreateCompanyParameters>());
var result = _companyService.CreateCompany(parameters);
result.EnsureSuccessWithHttpResponseException(HttpVerbs.Post);
return(new HttpResponseMessage(HttpStatusCode.Created)
{
Content = Get(result.ResultingObject).ToJSONContent()
});
}
public void CreateCompany()
{
var repository = new Mock <IRepository <Company> >();
var empService = new Mock <IEmployeeService>();
var compEmplSer = new Mock <ICompanyEmployeeService>();
var compService = new Mock <ICompanyService>();
var service = new CompanyService(repository.Object, empService.Object, compEmplSer.Object);
var company = new CreateCompanyRequest {
CompanyName = "Test", PrimeContactID = 2, IsLive = true
};
var companyResponse = new CompanyResponse {
CompanyName = "Test", IsLive = true
};
compService.Setup(r => r.CreateCompany(company)).ReturnsAsync(companyResponse);
var result = service.CreateCompany(company);
Assert.That(result, Is.Not.Null);
}
public async Task <IActionResult> Create([FromBody] CreateCompanyRequest company)
{
var claims = _jwtService.GetTokenClaims(Request.Headers["JWToken"]);
var email = claims.First().Value;
var user = await _userService.GetByEmail(email);
if (user == null)
{
return(Response(code: 404));
}
var createdCompany = await _companyService.Register(company, user);
if (createdCompany != null)
{
return(Response(createdCompany, 201));
}
else
{
return(Response(code: 400));
}
}
public async Task CreateCompany_UnsuccessfulRequest_ShouldThrowCompanyApiException()
{
// Arrange
var createCompanyRequest = new CreateCompanyRequest(Guid.NewGuid().ToString());
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadRequest,
RequestMessage = new HttpRequestMessage
{
RequestUri = new Uri("http://www.mock-web-address.com"),
},
};
var companyApi = this.fixture.GetCompanyApi(response);
// Act
Func <Task> act = async() => await companyApi.CreateCompanyAsync(createCompanyRequest);
// Assert
await act.Should().ThrowAsync <FactroApiException>();
}
public async stt::Task CreateCompanyResourceNames3Async()
{
moq::Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new moq::Mock <CompanyService.CompanyServiceClient>(moq::MockBehavior.Strict);
CreateCompanyRequest request = new CreateCompanyRequest
{
ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
Company = new Company(),
};
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.CreateCompanyAsync(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.CreateCompanyAsync(request.ParentAsTenantOrProjectName, request.Company, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Company responseCancellationToken = await client.CreateCompanyAsync(request.ParentAsTenantOrProjectName, request.Company, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public async Task When_Creating_Should_Write_To_Db_And_Return()
{
var request = new CreateCompanyRequest()
{
Name = "Company-Test-01"
};
var handler = new CreateCompanyRequestHandler(CreateDbContext());
var response = await handler.Handle(request, default);
Assert.NotNull(response);
Assert.AreEqual("Company-Test-01", response.Name);
Assert.AreNotEqual(Guid.Empty, response.CompanyId);
// ensure it is available in db
// create a new DbContext to really read from store
var dbContext = CreateDbContext();
var createdCompany = await dbContext.Companies.FindAsync(response.CompanyId);
Assert.NotNull(createdCompany);
Assert.AreEqual("Company-Test-01", createdCompany.Name);
Assert.AreEqual(response.CompanyId, createdCompany.CompanyId);
}
public async Task <CreateCompanyResponse> CreateCompanyAsync(CreateCompanyRequest createCompanyRequest)
{
if (createCompanyRequest == null)
{
throw new ArgumentNullException(nameof(createCompanyRequest), $"{nameof(createCompanyRequest)} can not be null.");
}
if (createCompanyRequest.Name == null)
{
throw new ArgumentNullException(nameof(createCompanyRequest), $"{nameof(createCompanyRequest.Name)} can not be null.");
}
var requestRoute = CompanyApiEndpoints.Base.Create();
var requestString = JsonConvert.SerializeObject(createCompanyRequest, this.jsonSerializerSettings);
var requestContent = ApiHelpers.GetStringContent(requestString);
var response = await this.httpClient.PostAsync(requestRoute, requestContent);
if (!response.IsSuccessStatusCode)
{
throw new FactroApiException(
"Could not create company.",
response.RequestMessage.RequestUri.ToString(),
response.StatusCode,
response.Content == null ? null : await response.Content.ReadAsStringAsync());
}
var responseContentString = await response.Content.ReadAsStringAsync();
var result =
JsonConvert.DeserializeObject <CreateCompanyResponse>(
responseContentString,
this.jsonSerializerSettings);
return(result);
}
public async Task <CompanyResponse> CreateCompany(CreateCompanyRequest request)
{
var companyNameCheck = await company.All().FirstOrDefaultAsync(x => x.CompanyName == request.CompanyName);
if (companyNameCheck != null)
{
return(new CompanyResponse {
Message = "Company exist"
});
}
var companyToAdd = new Company
{
CompanyName = request.CompanyName,
EmployeeID = request.PrimeContactID,
IsLive = true
};
company.Add(companyToAdd);
company.SaveChanges();
return(await company.All().Where(x => x.ID == companyToAdd.ID).ProjectTo <CompanyResponse>().SingleAsync());
}
