//יש להעלות את הפרויקט
//identity server
// [Authorize]//(Policy = Policies.CustomerPolicy)]
public async Task <IActionResult> PostUserAsync([FromBody] UsersRequest request)
{
// Get Employee by Id
var employee = await EmployeeService.GetEmployeeAsync(request.EmployeeId ?? 0);
//// ValIdate if entity exists
if (employee == null)
{
return(NotFound());
}
//אם קיים שם משתמש
var user = await EmployeeService.GetEmployeeByUserIdAsync(request.UserName);
if (user.Model != null)
{
throw new Exception("user name is alredy exist");
}
//אם קיים משתמש עם employee זה לא תקין
var useremployee = await EmployeeService.GetUserByEmployeeIdAsync(request.EmployeeId ?? 0);
if (useremployee.Model != null)
{
throw new Exception("user employee is alredy exist");
}
var entity = request.ToEntity();
var response = await EmployeeService.CreateUserAsync(entity);
return(response.ToHttpResponse());
}
public async Task <BaseResponse <bool> > SaveUser(UsersRequest user)
{
var idUser = user.idUser;
BaseResponse <bool> res = new BaseResponse <bool>();
res.response = await _usersRepository.SaveUser(user);
res.msg = "Se guardó el usuario con exito!";
if (!res.response)
{
res.msg = "Error al intentar guardar el usuario";
}
else
{
if (!String.IsNullOrEmpty(idUser.ToString()))
{
_emailService.Send(user.Email, "Actualizacion en su cuenta", "Se realizó un cambio en su cuenta de la aplicacion PruebaApis");
}
else
{
_emailService.Send(user.Email, "Creacion de cuenta", "Se ha creado una cuenta para la aplicacion PruebaApis");
}
}
return(res);
}
public void GenerateUserRequestAckTest()
{
string sender = "Tommy Two Tone";
string receiver = "Server";
string contents = "New Name";
IMessageHandler handler = new MessageHandler();
IMessage response = null;
Mock <IConnectionHandler> connectionHandlerMock = new Mock <IConnectionHandler>();
connectionHandlerMock.Setup(connectionHandler => connectionHandler.Name).Returns(contents);
connectionHandlerMock.Setup(connectionHandler => connectionHandler.SendMessage(It.IsAny <IMessage>()))
.Callback((IMessage message) =>
{
response = message;
});
ConcurrentDictionary <string, IConnectionHandler> connectionHandlers = new ConcurrentDictionary <string, IConnectionHandler>();
connectionHandlers.TryAdd(connectionHandlerMock.Object.Name, connectionHandlerMock.Object);
IRequest userRequest = new UsersRequest(sender, receiver, contents);
userRequest.ProcessMessage(connectionHandlerMock.Object, connectionHandlers, handler);
Assert.IsNotNull(response);
Assert.AreEqual(response.Command, MessageCommand.UsersAck);
}
public async Task <bool> SaveUser(UsersRequest user)
{
try
{
if (!String.IsNullOrEmpty(user.idUser.ToString()))
{
_context.Users.Update(user);
}
else
{
await _context.Users.AddAsync(user);
}
if (await _context.SaveChangesAsync() != 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
return(false);
}
}
public IActionResult Authenticate([FromBody][CustomizeValidator(RuleSet = ("authenticate"))] UsersRequest userRequest)
{
var result = _usersService.Authenticate(userRequest.Username, userRequest.Password);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, result.Data.UserId.ToString())
}),
Expires = DateTime.UtcNow.AddMinutes(20),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
result.Data.Token = tokenHandler.WriteToken(token);
return(Ok(result.Data));
}
public async Task AuthUserPass_LoginWithNewClient_LogsInSuccessfully()
{
using (var server = new VaultTestServer())
{
var client = server.TestClient();
var mountPoint = Guid.NewGuid().ToString();
await client.Sys.EnableAuth(mountPoint, "userpass", "Userpass Mount");
var username = Guid.NewGuid().ToString();
var password = Guid.NewGuid().ToString();
var usersRequest = new UsersRequest
{
Password = password,
Policies = new List <string> {
"default"
},
Ttl = "1h",
MaxTtl = "2h"
};
await client.Auth.Write($"{mountPoint}/users/{username}", usersRequest);
var loginRequest = new LoginRequest
{
Password = usersRequest.Password
};
var newClient = new VaultClient(new UriBuilder(server.ListenAddress).Uri);
var loginResponse = await newClient.Auth.Write <LoginRequest, NoData>($"{mountPoint}/login/{username}", loginRequest);
Assert.Equal(username, loginResponse.Auth.Metadata["username"]);
Assert.Equal(usersRequest.Policies, loginResponse.Auth.Policies);
Assert.NotNull(loginResponse.Auth.ClientToken);
}
}
/// <summary>
/// 禁用用户
/// </summary>
/// <param name="userrequest"></param>
/// <returns></returns>
public BasicResponse DisableUser(UsersRequest userrequest)
{
BasicResponse Result = new BasicResponse();
List <UserInfo> lstUserDTO = userrequest.UserInfo;
try
{
if (lstUserDTO.Count <= 0)
{
Result.Code = 1;
Result.Message = "传入参数异常";
return(Result);
}
foreach (UserInfo tempUserDTO in lstUserDTO)
{
tempUserDTO.UserFlag = 0;
var _request = ObjectConverter.Copy <UserInfo, UserModel>(tempUserDTO);
_Repository.Update(_request);
}
}
catch
{
Result.Code = 2;
Result.Message = "操作失败";
}
return(Result);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
UsersRequest request;
try
{
request = new UsersRequest
{
CatalogId = CatalogId,
SortBy = SortBy,
SortOrder = SortOrder,
Limit = Limit,
Page = Page,
OpcRequestId = OpcRequestId
};
response = client.Users(request).GetAwaiter().GetResult();
WriteOutput(response, response.Value);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task Users_GetAllUsers_ReturnsUsers()
{
var groupShareClient = Helper.GsClient;
var userRequest = new UsersRequest(1, 2, 7);
var users = await groupShareClient.User.GetAllUsers(userRequest);
Assert.True(users.Count > 0);
}
public override async Task <UsersReply> RevealUsers(UsersRequest request, ServerCallContext context)
{
var message = JsonConvert.SerializeObject(await this.chatRoomService.GetUsersPerChatRoom(request.Chatroom));
return(await new UsersReply {
Message = message
});
}
public JsonResult Edit(UsersRequest request)
{
Json reponse = new Json();
reponse.code = 200;
reponse.status = 0;
return(Json(reponse));
}
public ActionResult <UsersResponse> Save(UsersRequest request)
{
int userId = _userservice.SaveUser(request);
return(StatusCode((int)HttpStatusCode.OK, new UsersResponse {
ID = userId
}));
}
public int UserLogin(UsersRequest user)
{
string password = corverToPassword(user.password);
UsersModels userlogin = this.context.User.Where(a => a.username == user.username && a.password == password).FirstOrDefault();
int position_id = userlogin != null ? userlogin.position_id : 0;
return(position_id);
}
public async Task GetAllUsers()
{
var groupShareClient = await Helper.GetGroupShareClient();
var userRequest = new UsersRequest(1, 2, 7);
var users = await groupShareClient.User.GetAllUsers(userRequest);
Assert.True(users.Count > 0);
}
public void UsersRequest_can_properly_create_a_request_with_query_string_parameters()
{
var uRequest = new UsersRequest(ProjectName: "Mediflex", Environment: "Dev", locationoid: "101");
Assert.IsTrue(uRequest.UrlPath().Contains("datasets/Users.odm"));
Assert.IsTrue(uRequest.UrlPath().Contains(string.Format("studyoid={0}", Url.Encode(uRequest.studyoid))));
Assert.IsTrue(uRequest.UrlPath().Contains(string.Format("locationoid={0}", Url.Encode(uRequest.locationoid))));
}
public async Task <ResultHandler <IEnumerable <UserModel> > > GetUsers(UsersRequest request)
{
try
{
if (request == null)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(E_ErrorType.EntityNotValid));
}
Dictionary <string, string> nameValueCollection = new Dictionary <string, string>();
if (request.Id.HasValue)
{
nameValueCollection.Add("Id", request.Id.Value.ToString());
}
HttpRequestModel httpRequestModel = new HttpRequestModel()
{
MethodName = "Users",
CancellationToken = new System.Threading.CancellationToken(),
ClientName = E_HttpClient.Typicode,
CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead,
Headers = null,
HttpContent = null,
HttpMethod = System.Net.Http.HttpMethod.Get,
QueryString = nameValueCollection
};
var usersResult = await this._httpClientFactoryService.GetHttpResponse <User[]>(httpRequestModel);
if (!usersResult.Success)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(usersResult.ErrorType));
}
List <UserModel> result = new List <UserModel>();
foreach (User user in usersResult.Value)
{
result.Add(new UserModel()
{
Id = user.Id,
Name = user.Name
});
}
Thread.Sleep(TimeSpan.FromSeconds(_typicodeConfig.UsersThreadSleep));
return(ResultHandler.Ok <IEnumerable <UserModel> >(result));
}
catch (System.Exception ex)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(ex));
}
}
public async Task <ResultHandler <IEnumerable <UserModel> > > GetUsers(UsersRequest request)
{
try
{
if (request == null)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(E_ErrorType.EntityNotValid));
}
Dictionary <string, string> nameValueCollection = new Dictionary <string, string>();
nameValueCollection.Add("order", "desc");
nameValueCollection.Add("sort", "reputation");
nameValueCollection.Add("site", "stackoverflow");
HttpRequestModel httpRequestModel = new HttpRequestModel()
{
MethodName = "Users",
CancellationToken = new System.Threading.CancellationToken(),
ClientName = E_HttpClient.Stackoverflow,
CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead,
Headers = null,
HttpContent = null,
HttpMethod = System.Net.Http.HttpMethod.Get,
QueryString = nameValueCollection
};
var usersResult = await this._httpClientFactoryService.GetHttpResponse <UserResponse>(httpRequestModel);
if (!usersResult.Success)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(usersResult.ErrorType));
}
List <UserModel> result = new List <UserModel>();
foreach (User user in usersResult.Value.items)
{
result.Add(new UserModel()
{
Id = user.user_id,
Name = user.display_name
});
}
Thread.Sleep(TimeSpan.FromSeconds(this._stackoverflowConfig.UsersThreadSleep));
return(ResultHandler.Ok <IEnumerable <UserModel> >(result));
}
catch (System.Exception ex)
{
return(ResultHandler.Fail <IEnumerable <UserModel> >(ex));
}
}
public JsonResult List(UsersRequest request)
{
var list = _UsersIService.GetList(request);
var count = _UsersIService.GetCount(request);
Json reponse = new Json();
reponse.code = 200;
reponse.total = count;
reponse.data = list;
return(Json(reponse));
}
public override Task <UsersReply> GetUsers(UsersRequest request, ServerCallContext context)
{
IEnumerable <User> users = Enumerable.Range(1, 20).Select(
x => new User {
Id = x, Name = $"Name {x} from {request.DepartmentName}"
});
UsersReply response = new UsersReply();
response.ListOfUsers.AddRange(users);
return(Task.FromResult(response));
}
public RequestParams GetWhere(UsersRequest request)
{
if (request == null)
{
return(null);
}
RequestParams rp = new RequestParams();
//追加查询参数
if (!string.IsNullOrEmpty(request.Id))
{
rp.Params.Add(new Params()
{
key = "Id", value = request.Id, searchType = EnumBase.SearchType.Eq
});
}
if (!string.IsNullOrEmpty(request.UserName))
{
rp.Params.Add(new Params()
{
key = "UserName", value = request.UserName, searchType = EnumBase.SearchType.Like
});
}
if (!string.IsNullOrEmpty(request.Email))
{
rp.Params.Add(new Params()
{
key = "Email", value = request.Email, searchType = EnumBase.SearchType.Eq
});
}
//添加排序(多个排序条件,可以额外添加)
if (!string.IsNullOrEmpty(request.sortKey))
{
rp.Sort.Add(new Sort()
{
key = request.sortKey, searchType = (EnumBase.OrderType)request.sortType
});
}
else
{
rp.Sort = null;
}
//添加分页
if (request.pageIndex > 0)
{
rp.Paging.pageIndex = request.pageIndex;
rp.Paging.pageSize = request.pageSize;
}
else
{
rp.Paging = null;
}
return(rp);
}
public IActionResult Create([FromBody][CustomizeValidator(RuleSet = ("default,create"))] UsersRequest userRequest)
{
var user = _mapper.Map <Users>(userRequest);
var result = _usersService.Register(user, userRequest.Password);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(NoContent());
}
public async Task <UsersResponse> UpdateAsync(string id, UsersRequest request, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
await _client.SetAuthHeaderAsync(cancellationToken);
var content = JsonSerializer.Serialize(request, _client.Options);
var response = await _client.HttpClient.PatchAsync($"api/v2/users/{id}",
new StringContent(content, Encoding.UTF8, "application/json"), cancellationToken);
return(await _client.HandleResponseAsync <UsersResponse>(response, cancellationToken));
}
public override async Task GetUsers(UsersRequest request, IServerStreamWriter <UserReply> responseStream, ServerCallContext context)
{
_logger.LogInformation("Begin grpc call UserService.GetUsers");
var users = await _repository.GetEntities();
foreach (var user in users)
{
await responseStream.WriteAsync(ConvertToGRPCUser(user));
}
}
public Boolean ChangePassword([FromBody] UsersRequest usersRequest)
{
Users user = dbContext.Users.Where(u => u.Id == usersRequest.id && u.Password == usersRequest.oldPassword).SingleOrDefault();
if (user != null)
{
user.Password = usersRequest.newPassword;
dbContext.SaveChanges();
return(true);
}
return(false);
}
public async Task <UserTeacher> post(UsersRequest request)
{
scriptPass script = new scriptPass();
UserTeacher model = new UserTeacher();
model.Email = request.Email;
model.Password = script.script(request.Password);
model.Role = await _roleRepository.GetByIdAsync(request.RoleId);
return(await _repository.PostAsync(model));
}
public async Task put(int id, UsersRequest request)
{
scriptPass script = new scriptPass();
var model = await _repository.GetByIdAsync(id);
model.Email = request.Email;
model.Password = script.script(request.Password);
model.Role = await _roleRepository.GetByIdAsync(request.RoleId);
await _repository.Put(model);
}
public ActionResult <Users> SingIn([FromBody] UsersRequest usersRequest)
{
Users user = dbContext.Users.Where(u => u.Username == usersRequest.username && u.Password == usersRequest.password).SingleOrDefault();
if (user != null)
{
return(user);
}
else
{
return(user);
}
}
public async Task <ActionResult> Register([FromBody] UsersRequest request)
{
try
{
await _manager.post(request);
return(Ok());
}catch (Exception ex)
{
ex.Message.ToString();
return(BadRequest());
}
}
public RootResponse <UsersItem> UsersServiceGetFromGzip(UsersRequest usersRequest)
{
string usersRootResponse = "";
string url = "";
if (!string.IsNullOrEmpty(usersRequest.InName))
{
var inNameUrl = System.Web.HttpUtility.UrlEncode(usersRequest.InName);
url = $"{GetBaseUrlRequest(this.usersService, usersRequest)}{inNameAttr}{inNameUrl}";
}
else
{
url = GetBaseUrlRequest(this.usersService, usersRequest);
}
try
{
var uri = new Uri(url, UriKind.Absolute);
var request = (HttpWebRequest)WebRequest.Create(uri);
//KEY to decompress /!\
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
usersRootResponse = reader.ReadToEnd();
}
var jsonPostsRoot = JsonConvert.DeserializeObject <RootResponse <UsersItem> >(usersRootResponse);
jsonPostsRoot.StatusCode = response.StatusCode.ToString();
return(jsonPostsRoot);
}
}
catch (WebException webEx)
{
var responseErr = (HttpWebResponse)webEx.Response;
return(new RootResponse <UsersItem> {
StatusCode = responseErr.StatusDescription
});
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public IActionResult Update([CustomizeValidator(RuleSet = ("default,update"))] UsersRequest userRequest)
{
var userToUpdate = _unitOfWork.Users.GetById(userRequest.UserId);
if (userToUpdate == null)
{
return(NotFound());
}
var user = _mapper.Map <Users>(userRequest);
var result = _usersService.Update(user, userToUpdate, userRequest.Password);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(NoContent());
}
