public async Task <ActionResult> Delete(int id)
{
if (AuthorizationUtils.Authorized(Request, _config) == false)
{
return(Unauthorized());
}
await _data.Delete(id);
return(Ok());
}
public async Task <ActionResult <IEnumerable <JokeRecipient> > > Get()
{
if (AuthorizationUtils.Authorized(Request, _config) == false)
{
return(Unauthorized());
}
var recipients = await _data.GetAll();
return(recipients.ToList());
}
protected override async Task <Task> HandleRequirementAsync(AuthorizationHandlerContext context, OperationAuthorizationRequirement requirement, Issue issue)
{
ObjectId userId = context.User.GetUserId();
if (context.User is null || issue is null)
{
return(Task.CompletedTask);
}
Project issueProject = await _projectRepository.GetAsync(issue.ProjectId);
if (issueProject is null)
{
return(Task.CompletedTask);
}
Company issueCompany = await _companyRepository.GetAsync(issueProject.CompanyId);
if (issueCompany is null)
{
return(Task.CompletedTask);
}
IEnumerable <State> projectStates = issueProject.States;
if (projectStates is null)
{
return(Task.CompletedTask);
}
State currentIssueState = projectStates.FirstOrDefault(ps => ps.Id.Equals(issue.StateId));
if (currentIssueState is null)
{
return(Task.CompletedTask);
}
PropertyUser projectUser = issueProject.Users?.FirstOrDefault(usr => usr.UserId.Equals(userId));
PropertyUser companyUser = issueCompany.Users?.FirstOrDefault(usr => usr.UserId.Equals(userId));
IList <ObjectId> userRoles = AuthorizationUtils.RolesOfUser(projectUser, companyUser);
switch (currentIssueState.Phase)
{
case State.NegotiationPhase: ValidateRequirmentInNegotiationPhase(context, requirement, userRoles); break;
case State.ProcessingPhase: ValidateRequirmentInProcessingPhase(context, requirement, userRoles); break;
case State.ConclusionPhase: ValidateRequirmentInConclusionPhase(context, requirement, userRoles); break;
}
return(Task.CompletedTask);
}
public static async Task Restore(IConfiguration configuration, HttpClient httpClient)
{
var accessToken = await AuthorizationUtils.GetBearerToken(configuration);
var restoreUrl = RestoreUrlPattern
.Replace("{subscriptionId}", configuration[SubscriptionId])
.Replace("{resourceGroupName}", configuration[ResourceGroupName])
.Replace("{serviceName}", configuration[ServiceName])
.Replace("{api-version}", configuration[ApiVersion]);
var restoreName = $"{configuration[ServiceName]}/backup";
var contentPayload = $@"{{
""storageAccount"": ""{configuration[StorageAccount]}"",
""containerName"": ""{configuration[ContainerName]}"",
""backupName"": ""{restoreName}"",
""accessType"": ""SystemAssignedManagedIdentity""
}}";
var content = new StringContent(contentPayload, Encoding.UTF8, "application/json");
var request = new HttpRequestMessage(HttpMethod.Post, restoreUrl)
{
Content = content
};
request.Headers.Add("Authorization", $"Bearer {accessToken}");
var response = await httpClient.SendAsync(request);
try
{
response.EnsureSuccessStatusCode();
}
catch (HttpRequestException)
{
var responseContent = await response.Content.ReadAsStringAsync();
var errorModel = JsonSerializer.Deserialize <ApimErrorResponse>(
responseContent,
new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
Console.WriteLine("Error ({0}) with message ({1})", errorModel.Error.Code, errorModel.Error.Message);
Console.WriteLine();
throw;
}
Console.WriteLine("Location to check operation status: {0}", response.Headers.Location);
}
public async Task <IHttpActionResult> Post(RegistrationDTO item)
{
var userId = string.Empty;
if (!ModelState.IsValid)
{
LogManager.WriteLog("error", userId, this.Request.RequestUri.PathAndQuery, string.Format("{0}:{1}", JsonConvert.SerializeObject(item), JsonConvert.SerializeObject(ModelState))).Forget();
return(BadRequest(ModelState));
}
var error = string.Empty;
if (string.IsNullOrEmpty(item.Mobile) && string.IsNullOrEmpty(item.Email))
{
error = "Mobile or email are required";
DataClassesManager.ControllerLog("error", userId, this.Request.RequestUri.PathAndQuery, error);
return(BadRequest(error));
}
long?preUserId = 0;
var password = AuthorizationUtils.HashPassword(item.Password);
var validation = DataClassesManager.Register(item.Username.ToLower(), password.Hash, password.Salt, item.CountryId, IdentityUtils.GetIdentitiesXML(item.Mobile, item.Email), out preUserId, out error);
if (!string.IsNullOrEmpty(error))
{
LogManager.WriteLog("error", userId, this.Request.RequestUri.PathAndQuery, error).Forget();
return(BadRequest(error));
}
foreach (var v in validation)
{
IdentityUtils.ValidateIdentity(v);
}
LogManager.WriteLog("info", userId, this.Request.RequestUri.PathAndQuery, string.Format("{0}:{1}:{2}", preUserId, JsonConvert.SerializeObject(item), JsonConvert.SerializeObject(validation))).Forget();
return(Ok(new
{
RefId = preUserId,
Identity = from x in validation
where x.Immediate
select new IdentityDTO
{
TypeId = x.TypeId,
Value = x.Identity,
Token = x.Token
}
}
));
}
public async Task <ActionResult> Post([FromBody] JokeRecipient recipient)
{
if (AuthorizationUtils.Authorized(Request, _config) == false)
{
return(Unauthorized());
}
if (recipient == null || String.IsNullOrEmpty(recipient.Name) || String.IsNullOrEmpty(recipient.Email))
{
return(BadRequest());
}
var j = await _data.Add(recipient);
return(Ok());
}
public async Task <ActionResult> Post([FromBody] Joke joke)
{
if (AuthorizationUtils.Authorized(Request, _config) == false)
{
return(Unauthorized());
}
if (joke == null || String.IsNullOrEmpty(joke.JokeText))
{
return(BadRequest());
}
var j = await _data.Add(joke);
return(Ok());
}
protected void Page_Load(object sender, EventArgs e)
{
LoggerHelper.Start();
if (!IsPostBack)
{
string loginName = GetUserLogin();
LoggerHelper.Debug("loginName = " + loginName);
if (string.IsNullOrEmpty(loginName))
{
LoggerHelper.Debug("Session expired redirenting to logon page.");
Response.Redirect(Request.ApplicationPath + "/Logon.aspx");
}
if (!AuthorizationUtils.UserHavePermissions())
{
LoggerHelper.Debug("user don't have permissions to access this page redirenting.");
Response.Redirect(Request.ApplicationPath + "/InvalidAccess.aspx");
}
Entity user = GetUser(loginName);
if (user != null)
{
Session["CurrentUserName"] = user.GetProperty("UserName");
}
if (!Page.ClientScript.IsClientScriptBlockRegistered("menuGlobals"))
{
StringBuilder menuGlobals = new StringBuilder();
menuGlobals.Append("\n<script type='text/javascript'>\n");
AuthorizationUtils.AppendModulesInfo(menuGlobals);
menuGlobals.Append("const LOGIN_NAME = '").Append(loginName).Append("';\n");
if (user != null)
{
menuGlobals.Append("const USER_ID = '").Append(user.GetProperty("USE_ID")).Append("';\n");
menuGlobals.Append("const USER_NAME = '").Append(user.GetProperty("USER_NAME")).Append("';\n");
}
menuGlobals.Append("</script>");
Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "menuGlobals", menuGlobals.ToString());
}
}
LoggerHelper.End();
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
string id;
long? userId;
var error = string.Empty;
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); //tells browsers whether to expose the response to frontend JavaScript code
var username = context.UserName;
//EnforceEncodingInteroperability(ref username);
//byte[] userPassword = Convert.FromBase64String(context.Password);
using (AuthorizationRepository _repo = new AuthorizationRepository())
{
var userAuthInfo = _repo.ValidateSession(username);
id = userAuthInfo.Id;
userId = userAuthInfo.UserId;
if (userId < 0)
{
error = "Invalid username";
goto ErrorHandling;
}
var incoming = AuthorizationUtils.Hash(context.Password, userAuthInfo.Salt);
if (!(AuthorizationUtils.SlowEquals(incoming, userAuthInfo.Password)))
{
error = "Invalid username and or password";
goto ErrorHandling;
}
}
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, string.Format("{0}:{1}:{2}", id, username, userId)));
identity.AddClaim(new Claim(ClaimTypes.Role, "user"));
context.Validated(identity);
LogManager.WriteLog(string.Format("{0}/{1}", username, context.Password), JsonConvert.SerializeObject(context.OwinContext.Request.Headers.Values), null, null, "OK", string.Format("{0}:{1}", id, context.UserName)).Forget();
return;
ErrorHandling:
context.SetError("invalid_grant", error);
LogManager.WriteLog(string.Format("{0}/{1}", username, context.Password), JsonConvert.SerializeObject(context.OwinContext.Request.Headers.Values), null, null, "BadRequest", error).Forget();
return;
}
public JsonResult checkOutsideLogin(string name, string pwd, string type = "")
{
var result = "error";
var username = "";
IDictionary <string, string> paramDictionary = new Dictionary <string, string>();
paramDictionary.Add("userNo", name.Trim());
paramDictionary.Add("password", pwd.Trim());
AuthorizationParams ap = new AuthorizationParams();
ap.METHOD = "wavenet.fxsw.engin.login";
ap.TIMESTAMP = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss");
ap.URL = ConfigurationManager.AppSettings["apiUrl"].ToString();
ap.APP_KEY = CookieHelper.GetCookie(Request).app_key;
ap.APP_SECRET = CookieHelper.GetCookie(Request).app_secret;
ap.SESSION = CookieHelper.GetCookie(Request).app_session;
paramDictionary.Add("type", type);//unit person
var authorization = AuthorizationUtils.Authorization(ap, paramDictionary);
if (authorization.Contains("账号或密码错误"))
{
result = "error";
}
else
{
EnginSignInResponse signInResponse = JsonToObject <EnginSignInResponse>(authorization);
if (signInResponse != null && signInResponse.enginLoginResponse != null && signInResponse.enginLoginResponse.result == "True")
{
result = "sucess";
username = signInResponse.enginLoginResponse.name;
Session["name"] = username;
CookieHelper.WriteCookie("app_key", CookieHelper.GetCookie(Request).app_key, 0);
CookieHelper.WriteCookie("app_secret", CookieHelper.GetCookie(Request).app_secret, 0);
CookieHelper.WriteCookie("app_session", CookieHelper.GetCookie(Request).app_session, 0);
CookieHelper.WriteCookie("unit_name", username, 0);
CookieHelper.WriteCookie("token", name, 0);
CookieHelper.WriteCookie("type", type, 0);
}
}
return(Json(new { name = name, result = result }));
}
public async Task <ActionResult> Post([FromBody] string email)
{
if (AuthorizationUtils.Authorized(Request, _config) == false)
{
return(Unauthorized());
}
if (String.IsNullOrEmpty(email))
{
return(BadRequest());
}
await _emailer.EmailJoke(new JokeToEmail { Text = "Some funny joke.", Punchline = "funny punchline!" },
new List <ToEmailAddress> {
new ToEmailAddress {
Email = email, Name = "Recipient"
}
});
return(Ok("joke email sent"));
}
public JsonResult checkLogin(string name, string pwd)
{
var result = "error";
var username = "";
IDictionary <string, string> paramDictionary = new Dictionary <string, string>();
paramDictionary.Add("userNo", name.Trim());
paramDictionary.Add("password", pwd.Trim());
AuthorizationParams ap = new AuthorizationParams();
ap.TIMESTAMP = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss");
ap.URL = ConfigurationManager.AppSettings["loginUrl"].ToString();
var authorization = AuthorizationUtils.LoginAuthorization(ap, paramDictionary);
if (authorization.Contains("账号或密码错误"))
{
result = "error";
}
else
{
SignInResponse signInResponse = JsonToObject <SignInResponse>(authorization);
if (signInResponse != null && signInResponse.SignInAuthorizationFXSWRightResponse != null && signInResponse.SignInAuthorizationFXSWRightResponse.app_key != null && signInResponse.SignInAuthorizationFXSWRightResponse.app_key != "")
{
result = "sucess";
username = signInResponse.SignInAuthorizationFXSWRightResponse.unit_name;
Session["name"] = signInResponse.SignInAuthorizationFXSWRightResponse.unit_name;
CookieHelper.WriteCookie("app_key", signInResponse.SignInAuthorizationFXSWRightResponse.app_key, 0);
CookieHelper.WriteCookie("app_secret", signInResponse.SignInAuthorizationFXSWRightResponse.app_secret, 0);
CookieHelper.WriteCookie("app_session", signInResponse.SignInAuthorizationFXSWRightResponse.app_session, 0);
CookieHelper.WriteCookie("unit_id", signInResponse.SignInAuthorizationFXSWRightResponse.unit_id, 0);
CookieHelper.WriteCookie("unit_name", signInResponse.SignInAuthorizationFXSWRightResponse.unit_name, 0);
CookieHelper.WriteCookie("token", signInResponse.SignInAuthorizationFXSWRightResponse.token, 0);
CookieHelper.WriteCookie("role", signInResponse.SignInAuthorizationFXSWRightResponse.role, 0);
CookieHelper.WriteCookie("type", "", 0);
}
}
return(Json(new { name = name, result = result }));
}
public void clearHistory(string keyDialog)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.clearHistoryLogic(authorization.getUserId(), keyDialog);
}
public void createCommunication(CommunicationShortModel model)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.createCommunicationLogic(authorization.getUserId(), model);
}
public void leaveCommunication(string keyDialog)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.leaveCommunicationLogic(authorization.getUserId(), keyDialog);
}
public TotalProfileModel detailsStatistics(int profileId)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
return(logic.totalData(authorization.getUserId(), profileId));
}
public List <CommunicationDataModel> getCommunicationListByPart(int count, int number)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
return(logic.getCommunicationListByPartLogic(authorization.getUserId(), count, number));
}
public void addArduino(ArduinoModel model)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.addArduinoLogic(authorization.getUserId(), model);
}
public ArduinoListModel getAllArduino()
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
return(logic.getArduinoListLogic(authorization.getUserId()));
}
public void IsRead(string keyDialog)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.isReadMessageLogic(authorization.getUserId(), keyDialog);
}
public void removeArduino(int arduinoId)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.removeArduinoLogic(authorization.getUserId(), arduinoId);
}
public void deleteMessage(MessageDeleteListModel model)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.deleteMessageLogic(authorization.getUserId(), model);
}
public void addToken(string token)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.addTokenLogic(authorization.getUserId(), token);
}
public void settingDeleteProfileToCommunication(string keyDialog, int profileId)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.settingDeleteProfileToCommunicationLogic(authorization.getUserId(), keyDialog, profileId);
}
public void pinToTop(string keyDialog, bool isPin)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.pinToTopLogic(authorization.getUserId(), keyDialog, isPin);
}
public void refreshToken(string newToken)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.refreshTokenLogic(authorization.getUserId(), newToken);
}
public void settingChangeInfoCommunication(string keyDialog, CommunicationChangeModel model)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.settingChangeInfoCommunicationLogic(authorization.getUserId(), keyDialog, model);
}
public DialogModel getMessageListByPart(int count, int number, string keyDialog)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
return(logic.getMessageListByPartLogic(authorization.getUserId(), count, number, keyDialog));
}
public List <CommunicationDataModel> searchCommunicationByName(string searchName)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
return(logic.searchCommunicationByNameLogic(authorization.getUserId(), searchName));
}
public void sendMessage(MessageSendModel model, string keyDialog)
{
AuthorizationUtils authorization = new AuthorizationUtils(Request);
logic.sendMessageLogic(authorization.getUserId(), model, keyDialog);
}
