public async Task <int> ChangeOrganizationMembershipStatus(OrganizationMembership organizationMembership, int newStatusId)
{
var org = _organizationRepository.Get().SingleOrDefault(x => x.ApplicationId == organizationMembership.ApplicationId);
org.ApplicationStatusId = newStatusId;
return(await _organizationRepository.ModifyOrganizationMembership(org));
}
public void CanCreateAndDeleteOrganizationMemberships()
{
var org = api.Organizations.CreateOrganization(new Organization()
{
Name = "Test Org"
});
var user = new User()
{
Name = "Test User Org Mem",
Email = "*****@*****.**",
Role = "end-user"
};
var res = api.Users.CreateUser(user);
var org_membership = new OrganizationMembership()
{
UserId = res.User.Id, OrganizationId = org.Organization.Id
};
var res2 = api.Organizations.CreateOrganizationMembership(org_membership);
Assert.Greater(res2.OrganizationMembership.Id, 0);
Assert.True(api.Organizations.DeleteOrganizationMembership(res2.OrganizationMembership.Id.Value));
Assert.True(api.Users.DeleteUser(res.User.Id.Value));
Assert.True(api.Organizations.DeleteOrganization(org.Organization.Id.Value));
}
public async Task <int> ModifyOrganizationMembership(OrganizationMembership organizationMembership)
{
var org = _data.AsQueryable().SingleOrDefault(x => x.ApplicationId == organizationMembership.ApplicationId);
org = organizationMembership;
return(await SaveChangesAsync());
}
public SetupWithMembershipResult(
OrganizationMembership organizationMembership,
Organization organization,
UserResponse user)
: base(organization, user)
{
OrganizationMembership = organizationMembership;
}
public async Task <OrganizationMembership> PostForUserAsync(
OrganizationMembership organizationMembership,
long userId,
CancellationToken cancellationToken = default(CancellationToken))
{
return(await PostByUserIdAsync(
organizationMembership,
userId,
cancellationToken));
}
public async Task <OrganizationMembership> CreateAsync(
OrganizationMembership organizationMembership,
CancellationToken cancellationToken = default(CancellationToken))
{
var response = await CreateAsync <OrganizationMembershipResponse, OrganizationMembershipCreateRequest>(
ResourceUri,
new OrganizationMembershipCreateRequest(organizationMembership),
"create-membership",
cancellationToken: cancellationToken
);
return(response?
.OrganizationMembership);
}
public override async Task <Organization> CreateAsync(Organization entity)
{
var newEntity = await base.CreateAsync(entity);
// an org can only be created by the owner of the org. (for now anyway)
var membership = new OrganizationMembership {
User = newEntity.Owner,
Organization = newEntity
};
await OrganizationMembershipRepository.CreateAsync(membership);
return(newEntity);
}
public async Task <OrganizationMembership> PostByUserIdAsync(
OrganizationMembership organizationMembership,
long userId,
CancellationToken cancellationToken = default(CancellationToken))
{
var response = await CreateAsync <OrganizationMembershipResponse, OrganizationMembershipCreateRequest>(
string.Format(UsersUrlFormat, userId),
new OrganizationMembershipCreateRequest(organizationMembership),
"create-membership",
scope: $"PostByUserIdAsync({userId})",
cancellationToken : cancellationToken
);
return(response?
.OrganizationMembership);
}
public async Task <OrganizationMembership> PostForUserAsync(OrganizationMembership organizationMembership, string userId)
{
using (_loggerScope(_logger, $"PostAsync({userId})"))
using (var client = _apiClient.CreateClient())
{
var response = await client.PostAsJsonAsync(string.Format(UsersUrlFormat, userId), organizationMembership).ConfigureAwait(false);
if (response.StatusCode != System.Net.HttpStatusCode.Created)
{
throw new HttpRequestException(
$"Status code retrieved was {response.StatusCode} and not a 201 as expected" +
Environment.NewLine +
"See: https://developer.zendesk.com/rest_api/docs/core/tickets#create-ticket");
}
return(await response.Content.ReadAsAsync <OrganizationMembership>());
}
}
public async Task <IHttpActionResult> SetUserEmployer(OrganizationMembership organizationMembership)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_employerService.ValidateEmployer(organizationMembership.Employer))
{
BadRequest("Employer is not validate.");
}
var responseMessage = Request.CreateResponse(HttpStatusCode.OK);
// determine the uniqueness of the employer
var employer = _employerService.FindExistingEmployer(organizationMembership.Employer);
if (employer == null)
{
var userIdentity = ((ClaimsIdentity)User.Identity);
var userId = userIdentity.GetUserId();
var user = UserManager.Users.SingleOrDefault(s => s.Id == userId && s.Deleted != true && s.Disabled != true);
// set user organization
user.Organizations.Add(organizationMembership);
IdentityResult result = await UserManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
}
else
{
// Employer exists
var orgMembership = _organizationService.GetOrganizationMembershipByEmployer(employer);
responseMessage.StatusCode = HttpStatusCode.Found;
responseMessage.Content = new StringContent(string.Format("{0} {1}", orgMembership?.CreatedBy?.FirstName, orgMembership?.CreatedBy?.LastName));
}
return(ResponseMessage(responseMessage));
}
public void ValidatesOrganization_UpdateStatusTest()
{
// Arrange
var service = new OrganizationService(_organizationRepository);
var oldStatusId = 1;
var newStatusId = 2;
var employer = new Employer()
{
Id = "123456"
};
var organizationMembership = new OrganizationMembership {
ApplicationId = "2edbc12f-4fd9-4fed-a848-b8bfff4d4e32", Employer = employer, ApplicationStatusId = oldStatusId, IsPointOfContact = true
};
// Act
service.ChangeOrganizationMembershipStatus(organizationMembership, newStatusId);
var updatedOrganizationMembership = service.GetOrganizationMembershipByEmployer(employer);
// Assert
Assert.AreEqual(updatedOrganizationMembership.ApplicationStatusId, newStatusId);
}
public void Validate_PublicProperties()
{
var testDate = DateTime.Today;
var user = new ApplicationUser {
Id = "123"
};
var obj = new OrganizationMembership
{
CreatedAt = testDate,
LastModifiedAt = testDate,
CreatedBy = user,
CreatedBy_Id = "123",
LastModifiedBy = user,
LastModifiedBy_Id = "123"
};
Assert.AreEqual(testDate, obj.CreatedAt);
Assert.AreEqual(testDate, obj.LastModifiedAt);
Assert.AreEqual(user.Id, obj.CreatedBy_Id);
Assert.AreEqual(user.Id, obj.LastModifiedBy_Id);
}
public async Task <OrganizationMembership> CreateAsync(OrganizationMembership organizationMembership)
{
using (_loggerScope(_logger, $"PostAsync"))
using (var client = _apiClient.CreateClient())
{
var request = new OrganizationMembershipCreateRequest(organizationMembership);
var response = await client.PostAsJsonAsync(ResourceUri, request).ConfigureAwait(false);
if (response.StatusCode != System.Net.HttpStatusCode.Created)
{
throw new HttpRequestException(
$"Status code retrieved was {response.StatusCode} and not a 201 as expected" +
Environment.NewLine +
"See: https://developer.zendesk.com/rest_api/docs/core/tickets#create-ticket");
}
return((await response
.Content
.ReadAsAsync <OrganizationMembershipResponse>())
.OrganizationMembership);
}
}
public async Task <IndividualOrganizationMembershipResponse> CreateOrganizationMembershipAsync(long userId, OrganizationMembership organization_membership)
{
var body = new { organization_membership };
return(await GenericPostAsync <IndividualOrganizationMembershipResponse>($"users/{userId}/organization_memberships.json", body));
}
public IndividualOrganizationMembershipResponse CreateOrganizationMembership(long userId, OrganizationMembership organization_membership)
{
var body = new { organization_membership };
return(GenericPost <IndividualOrganizationMembershipResponse>($"users/{userId}/organization_memberships.json", body));
}
public IndividualOrganizationMembershipResponse CreateOrganizationMembership(OrganizationMembership organization_membership)
{
var body = new { organization_membership };
return(GenericPost <IndividualOrganizationMembershipResponse>("organization_memberships.json", body));
}
public async Task<IndividualOrganizationMembershipResponse> CreateOrganizationMembershipAsync(OrganizationMembership organization_membership)
{
return await GenericPostAsync<IndividualOrganizationMembershipResponse>("organization_memberships.json", new { organization_membership });
}
public async Task <int> ModifyOrganizationMembership(OrganizationMembership organizationMembership)
{
_dbContext.Entry(organizationMembership).State = EntityState.Modified;
return(await SaveChangesAsync());
}
public async Task <IHttpActionResult> CreateOrUpdateEmployerApplication(string employerId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Check user user permission
var userInfo = GetUserInfo();
var hasPermission = _identityService.HasAddPermission(userInfo, employerId);
if (!hasPermission)
{
Unauthorized("Unauthorized");
}
var responseMessage = Request.CreateResponse(HttpStatusCode.OK);
var userIdentity = ((ClaimsIdentity)User.Identity);
var userId = userIdentity.GetUserId();
var user = UserManager.Users.Include("Roles.Role").Include("Organizations").SingleOrDefault(s => s.Id == userId);
// Updated existing Application Id and Status
var organization = user.Organizations.FirstOrDefault(x => x.Employer_Id == employerId && string.IsNullOrEmpty(x.ApplicationId));
var applcationId = Guid.NewGuid().ToString();
if (organization != null)
{
organization.ApplicationId = applcationId;
organization.ApplicationStatusId = StatusIds.InProgress;
responseMessage.Content = new StringContent(string.Format("{{\"ApplicationId\": \"{0}\", \"ApplicationStatus\": \"{1}\" }}", applcationId, StatusIds.InProgress), Encoding.UTF8, "application/json");
IdentityResult result = await UserManager.UpdateAsync(user);
}
else
{
// Create new Application if no application is in progress.
// Application is considered to be in progress if today's date is in the same "calendar" year as the date
// application was created and hasn't been submitted yet.
// In other words, New application can be created for this employer if there is no application in
// progress with the same year for application creation date & today's date
var notSubmittedApplication = user.Organizations.LastOrDefault(x => x.Employer_Id == employerId && x.ApplicationStatusId != StatusIds.Submitted);
if (notSubmittedApplication == null || notSubmittedApplication.CreatedAt.Year < DateTime.Now.Year)
{
var org = user.Organizations.FirstOrDefault(x => x.Employer_Id == employerId);
var newOrganization = new OrganizationMembership()
{
EIN = org.EIN,
Employer_Id = org.Employer_Id,
IsPointOfContact = org.IsPointOfContact,
ApplicationId = applcationId,
ApplicationStatusId = StatusIds.InProgress
};
user.Organizations.Add(newOrganization);
responseMessage.Content = new StringContent(string.Format("{{\"ApplicationId\": \"{0}\", \"ApplicationStatus\": \"{1}\" }}", newOrganization.ApplicationId, StatusIds.InProgress), Encoding.UTF8, "application/json");
IdentityResult result = await UserManager.UpdateAsync(user);
}
else
{
responseMessage = Request.CreateResponse(HttpStatusCode.ExpectationFailed);
responseMessage.Content = new StringContent("Can not create new application");
}
}
return(ResponseMessage(responseMessage));
}
public OrganizationMembershipCreateRequest(OrganizationMembership membership)
{
OrganizationMembership = membership;
}
