public ActionResult <ReturnResponse> Post([FromBody] ProdutosAnteriores request)
{
ProdutosAnterioresRepository.Gravar(request);
var retorno = new ReturnResponse()
{
Code = 100,
Message = "Produto cadastrado com sucesso"
};
return(retorno);
}
public IActionResult GetAllClassesSubjectsByAccountId(int accountId)
{
List <QuestionAvailaleClassAndSubject> list = _repository.GetAllClassesSubjectsByAccountId(accountId);
if (list != null && list.Count > 0)
{
return(Ok(ReturnResponse.GetSuccessStatus(list)));
}
else
{
return(NotFound(ReturnResponse.Get(ReturnConstant.CLASS_SUBJECT_ALL_NOT_FOUND)));
}
}
public HttpResponseMessage UpdateEmployeeInfo([FromBody] EmployeeInfo employee)
{
//UpdateEmployeeInfo
int successFlag = EmployeeManagement.GetInstance.UpdateEmployeeInfo(employee);
ReturnResponse objReturnResponse = new ReturnResponse
{
result = (successFlag > 0? "Successfully updated the profile": "Failed to update"),
status = new ReturnStatus(successFlag.ToString(), (successFlag > 0? "Success": "Failure"))
};
return(Request.CreateResponse(HttpStatusCode.OK, objReturnResponse));
}
public IActionResult Register([FromBody] QuizUsers user)
{
ReturnResponse returnResponse = null;
int newUserId = _repository.Register(user);
returnResponse = ReturnResponse.Get(newUserId, user);
if (newUserId > 0)
{
return(Ok(returnResponse));
}
else
{
return(BadRequest(returnResponse));
}
}
/// <summary>
/// regist
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public ReturnResponse <User> Register(User user)
{
var response = new ReturnResponse <User>();
if (string.IsNullOrWhiteSpace(user.UserName))
{
response.Body = null;
response.ResponseCode = 100;
response.Message = "UserName can't be empty";
return(response);
}
if (string.IsNullOrWhiteSpace(user.UserPWD))
{
response.Body = null;
response.ResponseCode = 100;
response.Message = "UserPWD can't be empty";
return(response);
}
user.UserPWD = user.UserPWD.Md5Compute32();
var usersRes = GetUserListbyParameter(new UserQueryParameter()
{
UserName = user.UserName, Take = 1, IsPage = false
});
if (usersRes.IsSuccess && usersRes.Body.Items.Any())
{
response.Body = new User();
response.ResponseCode = 400;
response.Message = "UserName was exist";
return(response);
}
var res = _iUserDal.Save(user); //_IContainer.Resolve<IUserDAL>().Save(user);
if (res != null && res.Id > 0)
{
response.Body = res;
response.ResponseCode = 1;
response.Message = "regist success";
}
else
{
response.Body = res;
response.ResponseCode = -1;
response.Message = " Insert failed";
}
return(response);
}
public void GetInventoryItemAsync(InventoryItemBase item, ReturnResponse <InventoryItemBase> callBack)
{
System.Console.WriteLine("[HGrid] GetInventory from " + ServerURL);
try
{
RestSessionObjectPosterResponse <InventoryItemBase, InventoryItemBase> requester
= new RestSessionObjectPosterResponse <InventoryItemBase, InventoryItemBase>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(ServerURL + "/GetItem/", item, String.Empty, String.Empty);
}
catch (Exception e)
{
System.Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
}
}
public void GetInventoryItemAsync(InventoryItemBase item, ReturnResponse<InventoryItemBase> callBack)
{
System.Console.WriteLine("[HGrid] GetInventory from " + ServerURL);
try
{
RestSessionObjectPosterResponse<InventoryItemBase, InventoryItemBase> requester
= new RestSessionObjectPosterResponse<InventoryItemBase, InventoryItemBase>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(ServerURL + "/GetItem/", item, string.Empty, string.Empty);
}
catch (Exception e)
{
System.Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
}
}
public IActionResult Login([FromBody] UserLogin userLoginCredentials)
{
int returnCode = 0;
IActionResult returnResponse;
User loggedOnUser = _repository.Login(userLoginCredentials, out returnCode);
if (!(loggedOnUser == null))
{
returnResponse = Ok(ReturnResponse.Get(loggedOnUser));
}
else
{
returnResponse = BadRequest(ReturnResponse.Get(returnCode));
}
return(returnResponse);
}
private ReturnResponse MapRateLimits(HttpResponseMessage response)
{
response.Headers.TryGetValues("X-RateLimit-Limit", out var limitHeader);
response.Headers.TryGetValues("X-RateLimit-Remaining", out var remainingHeader);
response.Headers.TryGetValues("X-RateLimit-Reset", out var resetHeader);
var returnResponse = new ReturnResponse(_storage)
{
RateLimits = new RateLimits
{
Limit = Convert.ToInt32(limitHeader?.FirstOrDefault()),
Remaining = Convert.ToInt32(remainingHeader?.FirstOrDefault()),
Reset = Convert.ToInt64(resetHeader?.FirstOrDefault())
}
};
return(returnResponse);
}
private async Task <ReturnResponse> CreateReturnResponseFailure(ReturnResponse returnResponse,
HttpResponseMessage response)
{
returnResponse.IsOk = false;
var errorJson = await response.Content.ReadAsStringAsync();
try
{
returnResponse.FailureResponse =
ClSerializer.Deserialize <FailureResponse>(errorJson);
return(returnResponse);
}
catch (Exception e)
{
return(CreateReturnResponse(errorJson));
}
}
public IActionResult Update([FromBody] Question question)
{
if (question == null || question.options == null || question.questionType == null)
{
return(BadRequest(ReturnResponse.GetFailureStatus("Bad Request")));
}
int newQuestionId = _repository.UpdateQuestion(question);
if (newQuestionId > 0)
{
return(Ok(ReturnResponse.GetSuccessStatus("Successfully Inserted: new id is: " + newQuestionId.ToString())));
}
else
{
return(BadRequest("Failed to insert the question"));
}
}
/// <summary>
/// regist
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public ReturnResponse<User> Register(User user)
{
var response = new ReturnResponse<User>();
if (string.IsNullOrWhiteSpace(user.UserName))
{
response.Body = null;
response.ResponseCode = 100;
response.Message = "UserName can't be empty";
return response;
}
if (string.IsNullOrWhiteSpace(user.UserPWD))
{
response.Body = null;
response.ResponseCode = 100;
response.Message = "UserPWD can't be empty";
return response;
}
user.UserPWD = user.UserPWD.Md5Compute32();
var usersRes = GetUserListbyParameter(new UserQueryParameter() { UserName = user.UserName, Take = 1, IsPage = false });
if (usersRes.IsSuccess && usersRes.Body.Items.Any())
{
response.Body = new User();
response.ResponseCode = 400;
response.Message = "UserName was exist";
return response;
}
var res = _iUserDal.Save(user); //_IContainer.Resolve<IUserDAL>().Save(user);
if (res != null && res.Id > 0)
{
response.Body = res;
response.ResponseCode = 1;
response.Message = "regist success";
}
else
{
response.Body = res;
response.ResponseCode = -1;
response.Message = " Insert failed";
}
return response;
}
public IActionResult add([FromBody] Question question)
{
if (question == null || question.options == null || question.questionType == null)
{
return(BadRequest(ReturnResponse.GetFailureStatus("Bad Request")));
}
QuizQuestions ques = new QuizQuestions();
ques.Description = question.name;
ques.AccountId = question.accountId;
ques.ClassSubjectId = question.classSubjectId;
_context.QuizQuestions.Add(ques);
_context.SaveChanges();
int newQuestionId = ques.Id;
long correctAnswerId = 0;
foreach (Option o in question.options)
{
QuizQuestionsOptions opt = new QuizQuestionsOptions();
opt.Description = o.name;
opt.QuestionId = newQuestionId;
_context.QuizQuestionsOptions.Add(opt);
_context.SaveChanges();
if (o.isAnswer)
{
correctAnswerId = opt.Id;
}
}
ques.CorrectAnswerOptionId = correctAnswerId;
_context.QuizQuestions.Update(ques);
_context.SaveChanges();
return(Ok(ReturnResponse.GetSuccessStatus("Successfully Inserted: new id is: " + newQuestionId.ToString())));
}
public async Task <ReturnResponse <int> > CreateAccountAsync(Account account)
{
var returnResponse = new ReturnResponse <int>();
try
{
await _accountManagementContext.Accounts.AddAsync(account);
await _accountManagementContext.SaveChangesAsync();
returnResponse.Data = account.AccountId;
returnResponse.Succeeded = true;
}
catch (Exception ex)
{
returnResponse.Data = 0;
returnResponse.Error = ex.Message.ToString();
}
return(returnResponse);
}
public async virtual Task <ReturnResponse <T> > InsertAsync(string query, DynamicParameters parameters = null, CommandType commandType = CommandType.Text)
{
var returnResponse = new ReturnResponse <T>();
try
{
return(await _retryPolicy.ExecuteAsync(async() =>
{
using (var conn = CreateConnection())
{
returnResponse.Successful = await conn.ExecuteAsync(query, parameters, commandType: commandType) > 0;
return returnResponse;
}
}));
}
catch (Exception e)
{
returnResponse.Successful = false;
returnResponse.Error = e.Message;
return(returnResponse);
}
}
public ReturnResponse <UserInfoViewModels> Login(UserInfoViewModels userInfo)
{
var response = new ReturnResponse <UserInfoViewModels>();
var para = new UserInfoQueryParameter()
{
Account = userInfo.Account,
//Password = userInfo.Password.Md5Compute32(),
AccountType = userInfo.Account.GetAccountType(),
Take = 1,
IsPage = false
};
var res = Query(para);
if (res.IsSuccess && res.Body.Items.Any())
{
response.Body = res.Body.Items.FirstOrDefault();
if (response.Body != null && response.Body.DataStatus == 1)
{
response.ResponseCode = 403;
response.Message = "user has been forbidden";
}
else if (response.Body != null && !userInfo.Password.Md5Compute32().Equals(response.Body.Password))
{
response.ResponseCode = 400;
response.Message = "user name or password error";
}
else
{
response.ResponseCode = 1;
response.Message = "login success";
}
}
else
{
response.ResponseCode = 400;
response.Message = "user name doesn't exist";
}
return(response);
}
public ReturnResponse<UserInfoViewModels> Login(UserInfoViewModels userInfo)
{
var response = new ReturnResponse<UserInfoViewModels>();
var para = new UserInfoQueryParameter()
{
Account = userInfo.Account,
//Password = userInfo.Password.Md5Compute32(),
AccountType = userInfo.Account.GetAccountType(),
Take = 1,
IsPage = false
};
var res = Query(para);
if (res.IsSuccess && res.Body.Items.Any())
{
response.Body = res.Body.Items.FirstOrDefault();
if (response.Body != null && response.Body.DataStatus == 1)
{
response.ResponseCode = 403;
response.Message = "user has been forbidden";
}
else if (response.Body != null && !userInfo.Password.Md5Compute32().Equals(response.Body.Password))
{
response.ResponseCode = 400;
response.Message = "user name or password error";
}
else
{
response.ResponseCode = 1;
response.Message = "login success";
}
}
else
{
response.ResponseCode = 400;
response.Message = "user name doesn't exist";
}
return response;
}
public async Task <ReturnResponse <RegisterAccountViewModel> > RegisterAsync(CreateAccount createAccount)
{
var returnResponse = new ReturnResponse <RegisterAccountViewModel>();
var validator = new CreateAccountValidator(_userRepository);
ValidationResult validatorResult = await validator.ValidateAsync(createAccount);
if (validatorResult.Errors.Any())
{
returnResponse.Error = validatorResult.Errors.Join().ToString();
returnResponse.Succeeded = false;
return(returnResponse);
}
var account = new Account(createAccount.CompanyName, 1);
var responseAccount = await _accountRepository.CreateAccountAsync(account);
returnResponse.Succeeded = responseAccount.Succeeded;
returnResponse.Error = responseAccount.Error;
if (responseAccount.Succeeded)
{
var salt = AccountExetions.GeneraSalt();
var user = _mapper.Map <CreateAccount, User>(createAccount);
user.AccountId = account.AccountId;
user.UserTypeId = 1;
user.Password = AccountExetions.HashPassword(user.Password, salt);
user.HashSalt = salt;
var responseUser = await _userRepository.CreateUserAsync(user);
returnResponse.Data = _mapper.Map <User, RegisterAccountViewModel>(responseUser.Data);
returnResponse.Data.CompanyName = createAccount.CompanyName;
returnResponse.Data.TokenInfo = await _tokenService.GenerateTokenAsync(user);
returnResponse.Succeeded = responseUser.Succeeded;
returnResponse.Error = responseUser.Error;
}
return(returnResponse);
}
public async virtual Task <ReturnResponse <bool> > UpdateAsync(string query, DynamicParameters parameters = null, CommandType commandType = CommandType.Text)
{
var returnResponse = new ReturnResponse <bool>();
try
{
return(await _retryPolicy.ExecuteAsync(async() =>
{
using (var conn = CreateConnection())
{
returnResponse.Data = (await conn.ExecuteAsync(query, parameters, commandType: commandType)) > 0;
returnResponse.Succeeded = true;
return returnResponse;
}
}));
}
catch (Exception ex)
{
returnResponse.Succeeded = false;
returnResponse.Error = ex.Message.ToString();
return(returnResponse);
}
}
public IActionResult Edit(DTOSaveVersionInfo dto)
{
CheckVersionInfo(dto);
if (string.IsNullOrWhiteSpace(dto.ID))
{
throw new CustomExecption("9999", "ID不能为空");
}
ReturnResponse result = new ReturnResponse();
using (var unitOfWork = new UnitOfWork(DbContext))
{
var model = unitOfWork.VersionInfoRepository.Get(o => o.ID == Guid.Parse(dto.ID) && !o.IsDelete);
if (model == null)
{
throw new CustomExecption("9999", "获取版本信息失败");
}
if (unitOfWork.VersionInfoRepository.IsExist(o => o.VersionNo == dto.VersionNo && o.ID != model.ID && !o.IsDelete))
{
throw new CustomExecption("9999", $"已经存在版本号为{dto.VersionNo}的版本信息");
}
model.VersionNo = dto.VersionNo;
model.PublishDate = Convert.ToDateTime(dto.PublishDate).RemoveMilliSecond();
model.Context = Encoding.UTF8.GetBytes(dto.Content);
model.LastOperateUser = LoginUserInfo.CurrUser.LoginName;
model.LastUpdateTime = DateTime.Now.RemoveMilliSecond();
if (model.IsPublish)
{
// 如果是已发布的，则取消发布
model.IsPublish = false;
}
unitOfWork.VersionInfoRepository.Update(model);
unitOfWork.SaveChanges();
}
return(Json(result));
}
public async void LoginAsync(User user)
{
Func <Task <ReturnResponse <User> > > taskFunc = () =>
{
return(Task.Run(() =>
{
var response = new ReturnResponse <User>();
var paras = new UserQueryParameter()
{
UserName = user.UserName, UserPWD = user.UserPWD.Md5Compute32()
};
var res = GetUserListbyParameter(paras);
if (res.IsSuccess && res.Body.Items.Any())
{
response.Body = res.Body.Items.FirstOrDefault();
if (response.Body != null && response.Body.DataStatus == 1)
{
response.ResponseCode = 403;
response.Message = "user has been forbidden";
}
else
{
response.ResponseCode = 1;
response.Message = "login success";
}
}
else
{
response.ResponseCode = 400;
response.Message = "user name or password error";
}
return response;
}));
};
await taskFunc();
}
public async Task <ReturnResponse <RegisterAccountViewModel> > LoginAsync(AccountSignIn accountSignIn)
{
var returnResponse = new ReturnResponse <RegisterAccountViewModel>();
var validator = new AccountSignInValidator();
var validatorResult = await validator.ValidateAsync(accountSignIn);
if (validatorResult.Errors.Any())
{
returnResponse.Error = validatorResult.Errors.Join().ToString();
returnResponse.Succeeded = false;
return(returnResponse);
}
var user = await _userRepository.GetAndValidateAsync(accountSignIn);
if (user != null)
{
var tokenInfo = await _tokenService.GenerateTokenAsync(user);
returnResponse.Data = new RegisterAccountViewModel()
{
TokenInfo = new TokenInfo
{
AccessToken = tokenInfo.AccessToken,
ExpiredInMinute = tokenInfo.ExpiredInMinute,
RefreshToken = tokenInfo.RefreshToken
},
EmailAddress = user.EmailAddress,
FirstName = user.FirstName,
LastName = user.LastName
};
returnResponse.Succeeded = true;
return(returnResponse);
}
returnResponse.Succeeded = false;
return(returnResponse);
}
public static void FetchInventoryDescendants(string uri, InventoryFolderBase fb, ReturnResponse<InventoryCollection> callBack)
{
Console.WriteLine("[HGrid] FetchInventoryDescendants from " + uri);
try
{
RestSessionObjectPosterResponse<InventoryFolderBase, InventoryCollection> requester
= new RestSessionObjectPosterResponse<InventoryFolderBase, InventoryCollection>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(uri, fb, string.Empty, string.Empty);
}
catch (Exception e)
{
Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
}
}
public static bool CreateAsset(string uri, AssetBase asset, ReturnResponse<bool> callBack)
{
Console.WriteLine("[HGrid] CreateAsset to " + uri);
try
{
RestSessionObjectPosterResponse<AssetBase, bool> requester
= new RestSessionObjectPosterResponse<AssetBase, bool>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(uri, asset, string.Empty, string.Empty);
}
catch (Exception e)
{
Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
return false;
}
return true;
}
public static void InventoryItemOperation(string uri, InventoryItemBase item, ReturnResponse<InventoryItemBase> callBack)
{
Console.WriteLine("[HGrid] Inventory item operation " + uri);
try
{
RestSessionObjectPosterResponse<InventoryItemBase, InventoryItemBase> requester
= new RestSessionObjectPosterResponse<InventoryItemBase, InventoryItemBase>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(uri, item, string.Empty, string.Empty);
}
catch (Exception e)
{
Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
}
}
public string Validate(string name, string password)
{
ReturnResponse response = new ReturnResponse();
if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(password))
{
return(JsonConvert.SerializeObject(new ReturnResponse()
{
code = 500, message = "用户名或者密码错误", result = null
}));
}
using (var db = new DoCoverEntities())
{
try
{
password = Security.EncryptQueryString(password);
Users user = db.Users.FirstOrDefault(m => m.user_name == name && m.user_pwd == password);
if (user == null)
{
return(JsonConvert.SerializeObject(new ReturnResponse()
{
code = 500, message = "用户名或者密码错误", result = null
}));
}
if (user.user_status == false)
{
return(JsonConvert.SerializeObject(new ReturnResponse()
{
code = 501, message = $"账号 {user.user_name} 被禁用，原因：{user.user_remark ?? "无"}", result = null
}));
}
string data = user.user_type.ToString();
var ticket = new FormsAuthenticationTicket(2, user.user_id.ToString(), DateTime.Now, DateTime.Now.AddDays(1), true, data);
var cookieValue = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, cookieValue)
{
HttpOnly = true,
Secure = FormsAuthentication.RequireSSL,
Domain = FormsAuthentication.CookieDomain,
Path = FormsAuthentication.FormsCookiePath
};
cookie.Expires = DateTime.Now.AddDays(1);
var context = System.Web.HttpContext.Current;
context.Response.Cookies.Remove(cookie.Name);
context.Response.Cookies.Add(cookie);
user.user_login_num = (user.user_login_num ?? 0) + 1;
user.user_last_login_time = DateTime.Now;
user.user_last_login_ip = StaticMethod.GetClientIP();
db.SaveChanges();
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(new ReturnResponse(25001, ex.Message)));
}
}
return(JsonConvert.SerializeObject(new ReturnResponse()
{
code = 200, message = "", result = null
}));
}
public ReturnResponse <UserInfoViewModels> Register(UserInfoViewModels userInfo)
{
var response = new ReturnResponse <UserInfoViewModels>();
if (string.IsNullOrWhiteSpace(userInfo.Account))
{
response.Body = null;
response.ResponseCode = 100;
response.Message = "UserName can't be empty";
return(response);
}
if (string.IsNullOrWhiteSpace(userInfo.Password))
{
response.Body = null;
response.ResponseCode = 100;
response.Message = "UserPWD can't be empty";
return(response);
}
var usersRes = Query(new UserInfoQueryParameter()
{
Account = userInfo.Account, Take = 1, IsPage = false
});
if (usersRes.ResponseCode == 1 && usersRes.Body.Items.Any())
{
response.Body = new UserInfoViewModels();
response.ResponseCode = 400;
response.Message = "UserName was exist";
return(response);
}
userInfo.Password = userInfo.Password.Md5Compute32();
using (var trans = new TransactionScope())
{
try
{
var resUserInfo = _userInfoDal.Save(new UserInfo()
{
Password = userInfo.Password,
Address = userInfo.Address,
CompanyName = userInfo.CompanyName,
NickName = userInfo.NickName,
Gender = userInfo.Gender,
Remark = userInfo.Remark
}); //_IContainer.Resolve<IUserDAL>().Save(user);
if (resUserInfo.Id > 0)
{
_userInfoAccountDal.Save(new UserInfoAccount()
{
UserInfoID = resUserInfo.Id,
Account = userInfo.Account,
AccountType = userInfo.AccountType
});
userInfo.Id = resUserInfo.Id;
trans.Complete();
}
}
finally
{
trans.Dispose();
}
}
if (userInfo.Id > 0)
{
response.Body = userInfo;
response.ResponseCode = 1;
response.Message = "regist success";
}
else
{
response.Body = userInfo;
response.ResponseCode = -1;
response.Message = " Insert failed";
}
return(response);
}
public static void GetInventory(string uri, UUID userID, ReturnResponse<InventoryCollection> callBack)
{
Console.WriteLine("[HGrid] GetInventory from " + uri);
try
{
RestSessionObjectPosterResponse<Guid, InventoryCollection> requester
= new RestSessionObjectPosterResponse<Guid, InventoryCollection>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(uri, userID.Guid, string.Empty, string.Empty);
}
catch (Exception e)
{
Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
}
}
public static void InventoryFolderOperation(string uri, InventoryFolderBase folder, ReturnResponse<bool> callBack)
{
Console.WriteLine("[HGrid] Inventory folder operation " + uri);
try
{
RestSessionObjectPosterResponse<InventoryFolderBase, bool> requester
= new RestSessionObjectPosterResponse<InventoryFolderBase, bool>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(uri, folder, string.Empty, string.Empty);
}
catch (Exception e)
{
Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
}
}
public async void LoginAsync(User user)
{
Func<Task<ReturnResponse<User>>> taskFunc = () =>
{
return Task.Run(() =>
{
var response = new ReturnResponse<User>();
var paras = new UserQueryParameter() { UserName = user.UserName, UserPWD = user.UserPWD.Md5Compute32() };
var res = GetUserListbyParameter(paras);
if (res.IsSuccess && res.Body.Items.Any())
{
response.Body = res.Body.Items.FirstOrDefault();
if (response.Body != null && response.Body.DataStatus == 1)
{
response.ResponseCode = 403;
response.Message = "user has been forbidden";
}
else
{
response.ResponseCode = 1;
response.Message = "login success";
}
}
else
{
response.ResponseCode = 400;
response.Message = "user name or password error";
}
return response;
});
};
await taskFunc();
}
public static bool RequestAsset(string uri, InventoryItemBase item, ReturnResponse<AssetBase> callBack)
{
Console.WriteLine("[HGrid] GetAsset from " + uri);
try
{
RestSessionObjectPosterResponse<InventoryItemBase, AssetBase> requester
= new RestSessionObjectPosterResponse<InventoryItemBase, AssetBase>();
requester.ResponseCallback = callBack;
requester.BeginPostObject(uri, item, string.Empty, string.Empty);
}
catch (Exception e)
{
Console.WriteLine("[HGrid]: Exception posting to inventory: " + e);
return false;
}
return true;
}
/// <summary>
/// login
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public ReturnResponse<User> Login(User user)
{
var response = new ReturnResponse<User>();
var para = new UserQueryParameter() { UserName = user.UserName, UserPWD = user.UserPWD.Md5Compute32(), Take = 1, IsPage = false };
var res = GetUserListbyParameter(para);
if (res.IsSuccess && res.Body.Items.Any())
{
response.Body = res.Body.Items.FirstOrDefault();
if (response.Body != null && response.Body.DataStatus == 1)
{
response.ResponseCode = 403;
response.Message = "user has been forbidden";
}
else
{
response.ResponseCode = 1;
response.Message = "login success";
}
}
else
{
response.ResponseCode = 400;
response.Message = "user name or password error";
}
return response;
}
protected CommandUpdate(ReturnResponse <UpdateAccount> returnResponse)
{
ReturnResponse = returnResponse;
}
protected CommandBase(ReturnResponse <RegisterAccountViewModel> returnResponse)
{
ReturnResponse = returnResponse;
}
public HttpResponseMessage Login([FromBody] UserLogin user)
{
if (user == null || user.UserName == null || user.UserPassword == null)
{
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("Bad Request", Encoding.UTF8, "application/json")
});
}
//===============================================================================
User loggedOnUser = UserManagement.GetInstance.GetUserByLoginName(user.UserName);
//===============================================================================
ReturnResponse returnResponse = new ReturnResponse();
if (loggedOnUser == null || loggedOnUser.UserID.Equals(0))
{
returnResponse.result = "User not found!";
returnResponse.status = new ReturnStatus("-1", "User Not Found");;
var formatter = new JsonMediaTypeFormatter();
var content = new ObjectContent <ReturnResponse>(returnResponse, formatter, "application/json");
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = content
});
}
else if (Micro.Commons.MicroSecurity.Encrypt(user.UserPassword) != loggedOnUser.Password)
{
returnResponse.result = "Incorrect password!";
returnResponse.status = new ReturnStatus("-2", "Invalid Password!");;
var formatter = new JsonMediaTypeFormatter();
var content = new ObjectContent <ReturnResponse>(returnResponse, formatter, "application/json");
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = content
});
//var content = new ObjectContent<string>("woof", "text/plain", new[] { new PlainTextFormatter() }); // including formatters here doesn't actually help!
//var response = new HttpResponseMessage { Content = content };
//return response;
//return new HttpResponseMessage(HttpStatusCode.OK)
//{
// Content = new StringContent(JArray.FromObject(returnResponse).ToString(), Encoding.UTF8, "application/json")
//};
//HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Error message");
//return response;
}
else
{
List <User> userList = new List <User>();
userList.Add(loggedOnUser);
//ReturnStatus returnStatus = new ReturnStatus();
//returnStatus.Code = "1";
//returnStatus.Message = "Success";
//returnResponse.Result = userList;
//returnResponse.Status = returnStatus;
//var formatter = new JsonMediaTypeFormatter();
//var content = new ObjectContent<ReturnResponse>(returnResponse, formatter, "application/json");
//return new HttpResponseMessage { Content = content };
//return new HttpResponseMessage(HttpStatusCode.OK)
//{
// Content = content
//};
//return new HttpResponseMessage(HttpStatusCode.OK)
//{
// Content = new StringContent(JArray.FromObject(userList).ToString(), Encoding.UTF8, "application/json")
//};
ReturnResponse objReturnResponse = new ReturnResponse
{
result = loggedOnUser,
status = new ReturnStatus("1", "Success")
};
return(Request.CreateResponse(HttpStatusCode.OK, objReturnResponse));
}
}
public ReturnResponse<UserInfoViewModels> Register(UserInfoViewModels userInfo)
{
var response = new ReturnResponse<UserInfoViewModels>();
if (string.IsNullOrWhiteSpace(userInfo.Account))
{
response.Body = null;
response.ResponseCode = 100;
response.Message = "UserName can't be empty";
return response;
}
if (string.IsNullOrWhiteSpace(userInfo.Password))
{
response.Body = null;
response.ResponseCode = 100;
response.Message = "UserPWD can't be empty";
return response;
}
var usersRes = Query(new UserInfoQueryParameter() { Account = userInfo.Account, Take = 1, IsPage = false });
if (usersRes.ResponseCode == 1 && usersRes.Body.Items.Any())
{
response.Body = new UserInfoViewModels();
response.ResponseCode = 400;
response.Message = "UserName was exist";
return response;
}
userInfo.Password = userInfo.Password.Md5Compute32();
using (var trans = new TransactionScope())
{
try
{
var resUserInfo = _userInfoDal.Save(new UserInfo()
{
Password = userInfo.Password,
Address = userInfo.Address,
CompanyName = userInfo.CompanyName,
NickName = userInfo.NickName,
Gender = userInfo.Gender,
Remark = userInfo.Remark
}); //_IContainer.Resolve<IUserDAL>().Save(user);
if (resUserInfo.Id > 0)
{
_userInfoAccountDal.Save(new UserInfoAccount()
{
UserInfoID = resUserInfo.Id,
Account = userInfo.Account,
AccountType = userInfo.AccountType
});
userInfo.Id = resUserInfo.Id;
trans.Complete();
}
}
finally
{
trans.Dispose();
}
}
if (userInfo.Id > 0)
{
response.Body = userInfo;
response.ResponseCode = 1;
response.Message = "regist success";
}
else
{
response.Body = userInfo;
response.ResponseCode = -1;
response.Message = " Insert failed";
}
return response;
}
