public void GetAll_Called_CallsBuildUriWithFieldId()
{
// Given
_client.Setup(b => b.BuildUri(It.IsAny<string>(), It.IsAny<string>())).Returns(new Uri("http://search"));
var userResource = new UserResource(_client.Object);
// When
userResource.GetAll(new List<long> { 4321, 3456, 6789 });
// Then
_client.Verify(c => c.BuildUri(It.Is<string>(s => s.Contains("/show_many")), It.Is<string>(st => st.Contains("4321,3456,6789"))));
}
public void Post_Called_BuildsUri()
{
// Given
var request = new UserRequest { Item = new User { Name = "Owner Name" } };
var userResource = new UserResource(_client.Object);
// When
userResource.Post(request);
// Then
_client.Setup(b => b.BuildUri(It.IsAny<string>(), ""));
}
public void Get_Called_CallsBuildUriWithFieldId()
{
// Given
_client.Setup(b => b.BuildUri(It.IsAny<string>(), It.Is<string>(s => s.Contains("4321")))).Returns(new Uri("http://search"));
var userResource = new UserResource(_client.Object);
// When
userResource.Get(4321);
// Then
_client.Verify(c => c.BuildUri(It.Is<string>(s => s.Contains("4321")), ""));
}
public ZendeskClient(Uri baseUri, ZendeskDefaultConfiguration configuration, ISerializer serializer = null, IHttpChannel httpChannel = null, ILogAdapter logger = null)
:base(baseUri, configuration, serializer, httpChannel, logger)
{
Tickets = new TicketResource(this);
TicketComments = new TicketCommentResource(this);
Organizations = new OrganizationResource(this);
Search = new SearchResource(this);
Groups = new GroupsResource(this);
AssignableGroups = new AssignableGroupResource(this);
Users = new UserResource(this);
UserIdentities = new UserIdentityResource(this);
OrganizationMemberships = new OrganizationMembershipResource(this);
}
public void GetAll_Called_ReturnsUserResponse()
{
// Given
var response = new UserListResponse { Results = new List<User> { new User { Id = 1 } } };
_client.Setup(b => b.Get<UserListResponse>(It.IsAny<Uri>())).Returns(response);
var userResource = new UserResource(_client.Object);
// When
var result = userResource.GetAll(new List<long> { 4321, 3456, 6789 });
// Then
Assert.That(result, Is.EqualTo(response));
}
public void Get_Called_ReturnsUserResponse()
{
// Given
var response = new UserResponse { Item = new User { Id = 1 } };
_client.Setup(b => b.Get<UserResponse>(It.IsAny<Uri>())).Returns(response);
var userResource = new UserResource(_client.Object);
// When
var result = userResource.Get(4321);
// Then
Assert.That(result, Is.EqualTo(response));
}
public async Task <UserResponse> CreateUser(UserResource userResource)
{
User userRegistered = await unitOfWork.UserRepository.FindByEmailAsync(userResource.Email);
if (userRegistered != null)
{
return(new UserResponse(null, false, "Email is already registered"));
}
User user = mapper.Map <User>(userResource);
user.Password = passwordHasher.HashPassword(user.Password);
await unitOfWork.UserRepository.AddAsync(user);
await unitOfWork.Commit();
return(new UserResponse(mapper.Map <UserDTO>(user), true, null));
}
public static void Main(string[] args)
{
// Find your Account SID and Auth Token at twilio.com/console
// To set up environmental variables, see http://twil.io/secure
const string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
const string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
const string serviceSid = Environment.GetEnvironmentVariable("TWILIO_SERVICE_SID");
TwilioClient.Init(accountSid, authToken);
var users = UserResource.Read(serviceSid);
foreach (var user in users)
{
Console.WriteLine(user.Sid);
}
}
public void CreateAsync_UserRole()
{
using (var env = new TestEnvironment())
{
env.SetUser(User01Id, SystemRoles.User);
var resource = new UserResource
{
Id = "usernew"
};
var ex = Assert.ThrowsAsync <JsonApiException>(async() =>
{
await env.Service.CreateAsync(resource);
});
Assert.That(ex.GetStatusCode(), Is.EqualTo(StatusCodes.Status403Forbidden));
}
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var users = UserResource.Read(
segment: "premium",
pathServiceSid: "ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
);
foreach (var record in users)
{
Console.WriteLine(record.Sid);
}
}
public async Task <IActionResult> Login([FromBody] UserResource user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var myUser = await userManager.FindByEmailAsync(user.Email);
var result = await signInManager.CheckPasswordSignInAsync(myUser, user.Password, false);
if (!result.Succeeded)
{
return(BadRequest("Invalid credintial."));
}
await signInManager.SignInAsync(myUser, false);
return(Ok(this.GenerateWenToken(myUser, user.Email)));
}
/// <summary>
/// Updates the user.
/// </summary>
/// <param name="user">The user.</param>
public void UpdateUser(UserResource user, string updatedBy)
{
UserManager userMng = new UserManager();
var userDb = userMng.GetRecordById(user.Id);
if (userDb.Email != user.Email)
{
userDb.Email = user.Email;
}
if (userDb.Name != user.Name)
{
userDb.Name = user.Name;
}
userDb.UpdatedBy = updatedBy;
userMng.Update(userDb);
}
public async Task <IActionResult> CreateUser([FromBody] UserResource userResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var item = mapper.Map <UserResource, User>(userResource);
repository.Add(item);
await unitOfWork.CompleteAsync();
item = await repository.GetUserById(item.ID);
var result = mapper.Map <User, UserResource>(item);
return(Ok(result));
}
public virtual void SaveACL(HttpContext context)
{
YZRequest request = new YZRequest(context);
string rsid = request.GetString("rsid");
JArray post = request.GetPostData <JArray>();
URACECollection aces = post.ToObject <URACECollection>(request.Serializer);
using (BPMConnection cn = new BPMConnection())
{
cn.WebOpen();
URACL acl = new URACL();
acl.RSID = rsid;
acl.ACEs = aces;
UserResource.SaveACL(cn, acl);
}
}
public static void Main(string[] args)
{
// Find your Account SID and Auth Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
const string serviceSid = "ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
TwilioClient.Init(accountSid, authToken);
UserResource user = UserResource.create(
identity: "User0001",
segment: new List <string> {
"premium", "fitness-lifestyle"
});
Console.WriteLine(user.Sid);
}
public async Task <IActionResult> PostAsync(UserResourceViewModel userResourceDetail)
{
this.RecordEvent("User Resource- Http Post Call initiated.", RequestType.Initiated);
this.logger.LogInformation($"User Resource- Http Post Call initiated.");
try
{
if (userResourceDetail == null)
{
this.logger.LogError($"Error while saving user resource details to storage for userId: {this.UserObjectId}");
this.RecordEvent("User Resource - Http Post call failed.", RequestType.Failed);
return(this.BadRequest("Error while saving user resource details in storage."));
}
var userResourceEntity = new UserResource
{
UserId = this.UserObjectId,
ResourceId = userResourceDetail.ResourceId,
CreatedOn = DateTime.UtcNow,
};
var userResorces = await this.unitOfWork.UserResourceRepository.FindAsync(userResorce => userResorce.ResourceId == userResourceEntity.ResourceId && userResorce.UserId == userResourceEntity.UserId);
if (userResorces.Any())
{
this.logger.LogInformation($"User Resource - Http Post call succeeded.");
this.RecordEvent("User Resource - Http Post call succeeded.", RequestType.Succeeded);
return(this.Conflict(true));
}
this.unitOfWork.UserResourceRepository.Add(userResourceEntity);
await this.unitOfWork.SaveChangesAsync();
this.logger.LogInformation($"User Resource - Http Post call succeeded.");
this.RecordEvent("User Resource - Http Post call succeeded.", RequestType.Succeeded);
return(this.Ok(true));
}
catch (Exception ex)
{
this.RecordEvent("User Resource - Http Post call failed.", RequestType.Failed);
this.logger.LogError(ex, $"User Resource - Http Post call failed for user id: {this.UserObjectId}.");
throw;
}
}
public IActionResult Post([FromBody] UserResource user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var _user = _mapper.Map <User>(user);
_unitOfWork.UserRepository.Add(_user);
try
{
_unitOfWork.Done();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok(user));
}
public async Task <IActionResult> GetUserById(string id)
{
if (!(await _authorizationService.AuthorizeAsync(this.User, id, AccountManagementOperations.Read)).Succeeded)
{
return(new ChallengeResult());
}
UserResource userVM = await GetUserViewModelHelper(id);
if (userVM != null)
{
return(Ok(userVM));
}
else
{
return(NotFound(id));
}
}
public static bool PersistResourceValue(UserResource userResource, string token, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo)
{
bool returnValue = false;
foreach (var language in template.SupportedUILanguages)
{
var culture = new CultureInfo(language.LCID);
var value = userResource.GetValueForUICulture(culture.Name);
userResource.Context.ExecuteQueryRetry();
if (!string.IsNullOrEmpty(value.Value))
{
returnValue = true;
ResourceTokens.Add(new Tuple <string, int, string>(token, language.LCID, value.Value));
}
}
return(returnValue);
}
//Actual meat of construction is done here. This ctor is also used for testing
internal ClubHouseClient(HttpMessageHandler messageHandler)
{
if (messageHandler == null)
{
throw new ArgumentNullException(nameof(messageHandler));
}
HttpClient = new ClubHouseHttpClient(EndPoint, messageHandler);
Epics = new EpicResource(HttpClient);
Files = new FileResource(HttpClient);
Labels = new LabelResource(HttpClient);
LinkedFiles = new LinkedFileResource(HttpClient);
Projects = new ProjectResource(HttpClient);
StoryLinks = new StoryLinkResource(HttpClient);
Stories = new StoryResource(HttpClient);
Users = new UserResource(HttpClient);
Workflows = new WorkflowResource(HttpClient);
}
public IActionResult Update(int id, [FromBody] UserResource userResource)
{
// map dto to entity and set id
var user = _mapper.Map <User>(userResource);
user.Id = id;
try
{
// save
_userService.Update(user, userResource.Password);
return(Ok());
}
catch (Exception ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
// DANGER! This is insecure. See http://twil.io/secure
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var users = UserResource.Read(
pathServiceSid: "ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
limit: 20
);
foreach (var record in users)
{
Console.WriteLine(record.Sid);
}
}
public async void GetAsync_Called_ReturnsUserResponse()
{
// Given
var client = new Mock <IRestClient>();
var response = new UserResponse {
Item = new User {
Id = 1
}
};
client.Setup(b => b.GetAsync <UserResponse>(It.IsAny <Uri>(), It.IsAny <string>(), It.IsAny <string>())).Returns(TaskHelper.CreateTaskFromResult(response));
var userResource = new UserResource(client.Object);
// When
var result = await userResource.GetAsync(4321);
// Then
Assert.Equal(result, response);
}
public static void Main(string[] args)
{
// Find your Account SID and Auth Token at twilio.com/console
// To set up environmental variables, see http://twil.io/secure
const string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
const string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
const string serviceSid = Environment.GetEnvironmentVariable("TWILIO_SERVICE_SID");
TwilioClient.Init(accountSid, authToken);
UserResource user = UserResource.Create(
serviceSid, "User0001",
segment: new List <string> {
"premium", "fitness-lifestyle"
});
Console.WriteLine(user.Sid);
}
public async Task <ActionResult <UserResource> > UpdateUser(Guid id, [FromBody] UserResource userRequest)
{
var userToBeUpdate = await _userService.GetById(id);
if (userToBeUpdate == null)
{
return(NotFound());
}
var user = _mapper.Map <UserResource, User>(userRequest);
await _userService.Update(userToBeUpdate, user);
var updatedUser = await _userService.GetById(id);
var updatedUserResource = _mapper.Map <User, UserResource>(updatedUser);
return(Ok(updatedUserResource));
}
public ZendeskClient(Uri baseUri, ZendeskDefaultConfiguration configuration, ISerializer serializer = null, IHttpChannel httpChannel = null, ILogAdapter logger = null)
: base(baseUri, configuration, serializer, httpChannel, logger)
{
Tickets = new TicketResource(this);
TicketComments = new TicketCommentResource(this);
RequestComments = new RequestCommentResource(this);
Organizations = new OrganizationResource(this);
Search = new SearchResource(this);
Groups = new GroupsResource(this);
AssignableGroups = new AssignableGroupResource(this);
Users = new UserResource(this);
UserIdentities = new UserIdentityResource(this);
Upload = new UploadResource(this);
TicketFields = new TicketFieldResource(this);
TicketForms = new TicketFormResource(this);
OrganizationMemberships = new OrganizationMembershipResource(this);
Request = new RequestResource(this);
SatisfactionRating = new SatisfactionRatingResource(this);
}
/// <summary>
/// 检索用户资源
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private SyncResponse GetUserResourceByKey(SyncRequest request)
{
UserResource submitData = JsonHelper.DecodeJson <UserResource>(request.Data);
HttpClient myHttpClient = new HttpClient();
myHttpClient.BaseAddress = new Uri(webapi_url);//
HttpResponseMessage response = myHttpClient.GetAsync("GetUserResourceByKey?UserID=" + submitData.UserID + "&SubjectID=" + submitData.SubjectID + "&key=" + submitData.ResourceName).Result;
if (response.IsSuccessStatusCode)
{
string json = response.Content.ReadAsStringAsync().Result;
List <UserResource> list = JsonHelper.JosnDeserializer <UserResource>(json);
return(SyncResponse.GetResponse(request, list));
}
else
{
return(SyncResponse.GetResponse(request, null));
}
}
public IActionResult Update(int id, [FromBody] UserResource userResource)
{
// map resource to model
var user = _mapper.Map <User>(userResource);
user.Id = id;
try
{
// save
_userService.Update(user, userResource.Password);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(ex.Message));
}
}
protected virtual void ExpandTree(BPMConnection cn, JArray items, string rsid)
{
UserResourceCollection resources = UserResource.GetChildren(cn, rsid);
foreach (UserResource resource in resources)
{
JObject item = new JObject();
items.Add(item);
item["leaf"] = false;
item["text"] = resource.ResourceName;
item["iconCls"] = "folder";
item["expanded"] = false;
item["path"] = resource.RSID;
JArray children = new JArray();
item[YZJsonProperty.children] = children;
this.ExpandTree(cn, children, resource.RSID);
}
}
public async Task <AddUserResource> Handle(AddUserCommand request, CancellationToken cancellationToken)
{
if (_dataContext.Users.Any(x => x.Username == request.Username))
{
return(new AddUserResource(null, "Username is already taken"));
}
var user = new User()
{
Username = request.Username
};
user.PasswordHash = _passwordHasher.HashPassword(request.Password);
_dataContext.Users.Add(user);
await _dataContext.SaveChangesAsync();
return(new AddUserResource(UserResource.FromUser(user)));
}
public async Task <IActionResult> PostAppUSer(UserResource user)
{
var appUser = new AppUser()
{
UserName = user.name,
Name = user.name
};
try
{
var result = await _userManager.CreateAsync(appUser, user.password);
return(Ok(result));
}
catch (Exception ex)
{
throw ex;
}
}
private void ValidateUserResource(UserResource userResource)
{
if (userResource is null)
{
throw new ArgumentNullException(nameof(userResource));
}
if (string.IsNullOrWhiteSpace(userResource.Email))
{
throw new ArgumentNullException(nameof(userResource.Email));
}
if (string.IsNullOrWhiteSpace(userResource.FirstName))
{
throw new ArgumentNullException(nameof(userResource.FirstName));
}
if (string.IsNullOrWhiteSpace(userResource.LastName))
{
throw new ArgumentNullException(nameof(userResource.LastName));
}
if (string.IsNullOrWhiteSpace(userResource.Password))
{
throw new ArgumentNullException(nameof(userResource.Password));
}
if (string.IsNullOrWhiteSpace(userResource.Address))
{
throw new ArgumentNullException(nameof(userResource.Address));
}
if (string.IsNullOrWhiteSpace(userResource.City))
{
throw new ArgumentNullException(nameof(userResource.City));
}
if (string.IsNullOrWhiteSpace(userResource.State))
{
throw new ArgumentNullException(nameof(userResource.State));
}
if (string.IsNullOrWhiteSpace(userResource.ZipCode))
{
throw new ArgumentNullException(nameof(userResource.ZipCode));
}
if (string.IsNullOrWhiteSpace(userResource.PhoneNumber))
{
throw new ArgumentNullException(nameof(userResource.PhoneNumber));
}
}
public async Task <IActionResult> Register([FromBody] UserResource userResource)
{
// map dto to entity
var user = _mapper.Map <User>(userResource);
try
{
// save
var userSave = await _userService.Create(user, userResource.Password);
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_config.GetValue <string>("AppSettings:Secret"));
Microsoft.IdentityModel.Logging.IdentityModelEventSource.ShowPII = true;
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, userSave.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
// return basic user info (without password) and token to store client side
return(Ok(new
{
Id = user.Id,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Token = tokenString
}));
}
catch (Exception ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public void TestDeleteRequest()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
var request = new Request(
HttpMethod.Delete,
Twilio.Rest.Domain.Chat,
"/v2/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Users/USaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
""
);
twilioRestClient.Request(request).Throws(new ApiException("Server Error, no content"));
try
{
UserResource.Delete("ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "USaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", client: twilioRestClient);
Assert.Fail("Expected TwilioException to be thrown for 500");
}
catch (ApiException) {}
twilioRestClient.Received().Request(request);
}
private async Task <ApplicationUser> ResolveApplicationUserAsync(UserResource userResource)
{
var user = await DbContext.ApplicationUsers.FirstOrDefaultAsync(u => u.UserName == userResource.Username);
if (user == null)
{
user = new ApplicationUser {
UserName = userResource.Username, DisplayName = userResource.DisplayName
};
DbContext.ApplicationUsers.Add(user);
await DbContext.SaveChangesAsync();
}
else if (user.DisplayName != userResource.DisplayName)
{
user.DisplayName = userResource.DisplayName;
await DbContext.SaveChangesAsync();
}
return(user);
}
public void TestFetchRequest()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
var request = new Request(
HttpMethod.Get,
Twilio.Rest.Domain.IpMessaging,
"/v1/Services/ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Users/USXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
""
);
twilioRestClient.Request(request).Throws(new ApiException("Server Error, no content"));
try
{
UserResource.Fetch("ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "USXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", client: twilioRestClient);
Assert.Fail("Expected TwilioException to be thrown for 500");
}
catch (ApiException) {}
twilioRestClient.Received().Request(request);
}
public static bool PersistResourceValue(UserResource userResource, string token, ProvisioningTemplate template, ProvisioningTemplateCreationInformation creationInfo)
{
bool returnValue = false;
foreach (var language in template.SupportedUILanguages)
{
var culture = new CultureInfo(language.LCID);
var value = userResource.GetValueForUICulture(culture.Name);
userResource.Context.ExecuteQueryRetry();
if (!string.IsNullOrEmpty(value.Value))
{
returnValue = true;
ResourceTokens.Add(new Tuple<string, int, string>(token, language.LCID, value.Value));
}
}
return returnValue;
}
public void Post_CalledWithUser_ReturnsUserReponse()
{
// Given
var response = new UserResponse { Item = new User { Name = "Owner Name" } };
var request = new UserRequest { Item = new User { Name = "Owner Name" } };
_client.Setup(b => b.Post<UserResponse>(It.IsAny<Uri>(), request, "application/json")).Returns(response);
var userResource = new UserResource(_client.Object);
// When
var result = userResource.Post(request);
// Then
Assert.That(result, Is.EqualTo(response));
}
public static void Post(string format)
{
var c = new RestClient(baseUrl);
var model = new UserResource
{
UserName = "******" + Guid.NewGuid().ToString(),
Name = "RestClient user",
IsAnonymous = false
};
c.PostAsync<UserResource>(CreateRequest(Method.POST, "json").AddBody(model),
(resp, result) => WriteResult("POST", resp));
}
