public StudentController()
{
var contextWrapper = new TokenContainer();
var apiClient = new ApiClient(HttpClientInstance.Instance, contextWrapper);
client = new StudentCourseClient(apiClient);
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
//if (!ModelState.IsValid)
//{
// return View(model);
//}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
AuthorizationPresenter presenter = new AuthorizationPresenter();
var token = presenter.Authenticate(model.UserName, model.Password, "1");
if (token != null)
{
TokenContainer.SetToken(token);
}
//var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (token.HasLogin)
{
case true:
return(RedirectToLocal(returnUrl));
case false:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public OAuthContext(
string consumerKey,
string consumerSecret,
string requestUri,
string authorizationUri,
string accessUri,
string callbackUri,
bool isOutOfBand,
SignatureMethods signatureMethod)
{
ConsumerToken = new TokenContainer
{
Token = consumerKey,
Secret = consumerSecret,
};
RequestUri = new Uri(requestUri);
AuthorizationUri = new Uri(authorizationUri);
AccessUri = new Uri(accessUri);
if (callbackUri != null)
{
CallbackUri = new Uri(callbackUri);
}
IsOutOfBand = isOutOfBand;
SignatureMethod = signatureMethod;
}
public List <InspectionDetail> GetInspectionDetailList(string jobNumber, string inspectionRefNum, string CCode, string UCode)
{
ITokenContainer tokenContainer = new TokenContainer();
string urls = string.Empty;
InspectRootObject responseFromWS = new InspectRootObject();
try
{
string reference = "api/Customs/Invoice/GetInspectionReport";
string url = InternetService_URLS + reference;
urls = url + "?jobNumber=" + jobNumber + "&referenceNumber=" + inspectionRefNum;
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(urls);
webRequest.Method = "GET";
webRequest.Headers.Add("Authorization", "Bearer " + tokenContainer.ApiToken);
webRequest.Headers.Add("CCode", CCode);
webRequest.Headers.Add("UCode", UCode);
webRequest.Accept = "application/json";
using (WebResponse response = webRequest.GetResponse())
{
using (StreamReader rd = new StreamReader(response.GetResponseStream()))
{
var obj = rd.ReadToEnd();
responseFromWS = JsonConvert.DeserializeObject <InspectRootObject>(obj);//.Add(JsonConvert.DeserializeObject<InspectRootObject>(obj));
}
}
}
catch (Exception ex)
{
throw ex;
}
// InspectRootObject Inspection = new InspectRootObject(responseFromWSS);
return(responseFromWS.Data.InspectionDetail);
}
public ChatCodeContainer CreateChatCode([FromBody] TokenContainer tokenContainer)
{
string institutionId = AuthenticationService.GetInstitutionId(tokenContainer.Token).ToString();
string userId = AuthenticationService.GetUserId(tokenContainer.Token).ToString();
return(chatService.CreateChatCode(userId, institutionId));
}
public async Task <ActionResult> DownloadExcelGMSStatusReport(string obj)
{
var arg = JsonConvert.DeserializeObject <CustomClearanceBIZSearchDTO>(obj);
ITokenContainer tokenContainer = new TokenContainer();
if (tokenContainer.ApiToken == null)
{
string token = Request.Cookies["mta"] != null ? Request.Cookies["mta"].Value : null;
if (!String.IsNullOrEmpty(token))
{
tokenContainer.ApiToken = token;
}
}
if (tokenContainer.ApiToken == null)
{
return(Json(new
{
redirectUrl = Url.Action("LogOff", "Account"),
isRedirect = true
}, JsonRequestBehavior.AllowGet));
}
const string FILE_TYPE = "XLS";
var helper = new GMSDashboardHelper();
var path = Server.MapPath(@"~/");
var contents = await helper.GetReport(FILE_TYPE, path, arg);
string mimeType = "vnd.ms-excel";
return(File(contents, string.Format("application/{0}", mimeType), "StatusReport.xls"));
}
public LecturesController()
{
var contextWrapper = new TokenContainer();
var httpclient = HttpClientInstance.Instance;
var apiClient = new ApiClient(httpclient, contextWrapper);
client = new LectureClient(apiClient);
}
public QuestionController()
{
var contextWrapper = new TokenContainer();
var httpclient = HttpClientInstance.Instance;
var apiClient = new ApiClient(httpclient, contextWrapper);
client = new QuestionClient(apiClient);
}
protected override string Render()
{
string loginStatus = "Out";
string firstValue = Utility.GetQueryValue("FirstValue", "");
string IDValue = Utility.GetQueryValue("ID", "");
string template = this.websitePageContent.TemplateFile;
string hasIDValue = "";
if (this.Context.User.Identity.IsAuthenticated && string.IsNullOrEmpty(this.Context.User.Identity.Name) == false)
{
loginStatus = "In";
}
if (string.IsNullOrEmpty(IDValue) == false)
{
hasIDValue = "Edit";
}
if (string.IsNullOrEmpty(this.websitePageContent.TemplateFile) == false)
{
string templateContent = "";
TokenContainer tokenContainer = null;
tokenContainer = ProviderBase.Data.Utility.XMLDeseralize <TokenContainer>(HttpContext.Current.Server.MapPath(@"/Resource/XML/") + this.websitePageContent.TokenFile);
template = template.Replace("$LOGINSTATUS$", loginStatus);
template = template.Replace("$FIRSTVALUE$", firstValue);
template = template.Replace("$IDVALUE$", hasIDValue);
templateContent = ProviderBase.Web.Utility.GetResourceHtml(template);
if (tokenContainer != null && tokenContainer.TokenItemList?.Count > 0)
{
foreach (TokenItem tokenItem in tokenContainer.TokenItemList)
{
string tokenItemHtml = "";
switch (tokenItem.TokenItemTypeID)
{
case TokenItemType.Text:
templateContent = templateContent.Replace(tokenItem.Token, tokenItem.Text);
break;
case TokenItemType.File:
tokenItemHtml = ProviderBase.Web.Utility.GetResourceHtml(tokenItem.Text);
templateContent = templateContent.Replace(tokenItem.Token, tokenItemHtml);
break;
}
}
}
return(templateContent);
}
else
{
return("");
}
}
public AssignmentController()
{
var contextWrapper = new TokenContainer();
var httpclient = HttpClientInstance.Instance;
var apiClient = new ApiClient(httpclient, contextWrapper);
client = new AssignmentsClient(apiClient);
tclient = new AssignmentTypeClient(apiClient);
}
public async Task <bool> LogOff()
{
ITokenContainer tokenContainer = new TokenContainer();
ApiHelper.Client.ApiClient client = new ApiHelper.Client.ApiClient(HttpClientInstance.Instance, tokenContainer);
GenericClient cb = new GenericClient(client);
await cb.Post("Account/LogOff", new { });
return(true);
}
public async Task <ApiResponse> Register(LoginViewModel data)
{
ITokenContainer tokenContainer = new TokenContainer();
ApiHelper.Client.ApiClient client = new ApiHelper.Client.ApiClient(HttpClientInstance.Instance, tokenContainer);
GenericClient cb = new GenericClient(client);
var response = await cb.Post("Account/CreatePassword", data);
return(response);
}
public HomeController()
{
var contextWrapper = new TokenContainer();
var httpclient = HttpClientInstance.Instance;
httpclient = GlobalURL.AddHeader(httpclient);
var apiClient = new ApiClient(httpclient, contextWrapper);
client = new CourseClient(apiClient);
cclient = new CurrentSemesterClient(apiClient);
}
public void LogOut(Guid id)
{
if (TokenContainer.GetContext().LoggedUsers.ContainsKey(id))
{
TokenContainer.GetContext().LoggedUsers.Remove(id);
}
else
{
throw new UserNotExistException("El usuario no se encuentra loggeado en el sistema.");
}
}
public void Unregister <T>(MonoBehaviour listener)
{
string tag = SubscriptionTag <T>(listener);
if (_CachedTokens.ContainsKey(tag))
{
TokenContainer container = _CachedTokens[tag];
_CachedTokens.Remove(tag);
TinyMessengerHub.Instance.Unsubscribe(container.Token, container.MessageType);
}
}
//public List<GMSContainerStatusResponse> GetGMSReleaseReportData(string x)
public List <GMSContainerStatusResponse> GetGMSReleaseReportData(CustomClearanceBIZSearchDTO arg)
{
ITokenContainer tokenContainer = new TokenContainer();
string urls = string.Empty;
GMSStatRootResponse responseFromWS = new GMSStatRootResponse();
try
{
string reference = "api/Customs/Dashboard/SearchContainerReleaseReport";
string url = InternetService_URLS + reference;
//CustomClearanceBIZSearchDTO arg = new CustomClearanceBIZSearchDTO();
//arg.gmsDashboardSearchFilter = new GMSDashboardSearchFilter();
//arg.gmsDashboardSearchFilter.pageNo = 1;
//arg.gmsDashboardSearchFilter.pageSize = 100;
//arg.gmsDashboardSearchFilter.toDT = "2018-11-02 00:00:00";
//urls = url + "?centerCode=" + centerCode + "&jobNumber=" + jobNumber + "&eLACode=" + eLACode;
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url);
webRequest.ContentType = "application/json";
webRequest.Method = "POST";
webRequest.Headers.Add("Authorization", "Bearer " + tokenContainer.ApiToken);
webRequest.Accept = "application/json";
using (var streamWriter = new StreamWriter(webRequest.GetRequestStream()))
{
string json = JsonConvert.SerializeObject(arg);
streamWriter.Write(json);
streamWriter.Flush();
streamWriter.Close();
}
using (WebResponse response = webRequest.GetResponse())
{
using (StreamReader rd = new StreamReader(response.GetResponseStream()))
{
var obj = rd.ReadToEnd();
responseFromWS = JsonConvert.DeserializeObject <GMSStatRootResponse>(obj);
}
}
}
catch (Exception ex)
{
throw ex;
}
List <GMSContainerStatusResponse> result = new List <GMSContainerStatusResponse>(responseFromWS.ServiceResponse.Content);
//List<Exemptions> Exemptionss = new List<Exemptions>(responseFromWS.FirstOrDefault().Data);
//Exemptionss.Add(Exemptions.FirstOrDefault());
return(result);
}
public UserDTO GetUserLoggedIn(Guid id)
{
UserDTO userDTO = null;
if (TokenContainer.GetContext().LoggedUsers.ContainsKey(id))
{
userDTO = TokenContainer.GetContext().LoggedUsers[id];
}
else
{
throw new UserNotExistException("El usuario no se encuentra loggeado en el sistema.");
}
return(userDTO);
}
public CourseController()
{
var contextWrapper = new TokenContainer();
var httpclient = HttpClientInstance.Instance;
httpclient = GlobalURL.AddHeader(httpclient);
var apiClient = new ApiClient(httpclient, contextWrapper);
sclient = new StudentCourseClient(apiClient);
aclient = new AttendanceClient(apiClient);
nclient = new NoteClient(apiClient);
gclient = new GradeClient(apiClient);
cclient = new CLOClient(apiClient);
statclient = new StatisticsClient(apiClient);
}
public string GetToken()
{
var r = new Random();
var bytes = new byte[32];
r.NextBytes(bytes);
var tc = new TokenContainer
{
Token = Convert.ToBase64String(bytes).Replace("=", "").Replace("+", "").Replace("/", ""),
ValidBy = DateTime.Now.AddMinutes(30)
};
Tokens.Add(tc);
return(tc.Token);
}
public async Task <AuthenticationResponse> AuthenticateAsync(AuthenticationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request is null");
}
if (string.IsNullOrEmpty(request.UserId) || string.IsNullOrEmpty(request.Password))
{
throw new ArgumentException("invalid authentication request");
}
if (_logger != null)
{
_logger.LogInformation(JsonSerializer.Serialize(request));
}
bool validationResult = await _userManager.ValidateCredentials(request.UserId, request.Password);
if (_logger != null)
{
_logger.LogInformation("credentials validation result: " + validationResult);
}
if (!validationResult)
{
return(new AuthenticationResponse()
{
IsSuccessful = false,
AccessToken = null,
AccessTokenExpiresIn = null,
RefreshToken = null,
RefreshTokenExpiresIn = null
});
}
TokenContainer tokenContainer = _tokenManager.GenerateNewTokens(request.UserId);
return(new AuthenticationResponse()
{
IsSuccessful = true,
AccessToken = tokenContainer.AccessToken.AsString,
AccessTokenExpiresIn = tokenContainer.AccessToken.ExpiresIn,
RefreshToken = tokenContainer.RefreshToken.AsString,
RefreshTokenExpiresIn = tokenContainer.RefreshToken.ExpiresIn
});
}
private void LogErrorInMgApp(string targetUrl, string data, string response)
{
ITokenContainer tokenContainer = new TokenContainer();
ApiHelper.Client.ApiClient client = new ApiHelper.Client.ApiClient(HttpClientInstance.Instance, tokenContainer);
GenericClient cb = new GenericClient(client);
cb.LogErrorinMgApp("PCSWEBREQUESTURL:" + targetUrl);
if (data != null)
{
cb.LogErrorinMgApp("PCSWEBDATA:" + data);
}
if (response != null)
{
cb.LogErrorinMgApp("PCSWEBRESPONSE:" + response);
}
}
//The HttpClient Class, this will be used for performing
//HTTP Operations, GET, POST, PUT, DELETE
//Set the base address and the Header Formatter
public MstTypeOfRekananController()
{
string SmartAPIUrl = ConfigurationManager.AppSettings["SmartAPIUrl"];
url = string.Format("{0}/api/MstTypeOfRekanan", SmartAPIUrl);
var contextWrapper = new TokenContainer();
client = new HttpClient();
client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (contextWrapper.ApiToken != null)
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", contextWrapper.ApiToken.ToString());
}
}
static void SetupConnection(string host, string cameraUuid, string deviceId, string token)
{
var tc = new TokenContainer();
tc.OliveToken = token;
using (var mStream = new MemoryStream())
{
Serializer.Serialize(mStream, tc);
var helloRequestBuffer = new HelloContainer();
helloRequestBuffer.ProtocolVersion = 3;
helloRequestBuffer.Uuid = cameraUuid;
helloRequestBuffer.DeviceId = deviceId;
helloRequestBuffer.RequireConnectedCamera = false;
helloRequestBuffer.UserAgent = USER_AGENT;
helloRequestBuffer.ClientType = 3;
helloRequestBuffer.AuthorizeRequest = mStream.GetBuffer();
using (var finalMStream = new MemoryStream())
{
Serializer.Serialize(finalMStream, helloRequestBuffer);
var dataBuffer = PreformatData(PacketType.HELLO, finalMStream.ToArray());
var target = $"wss://{host}";
Console.WriteLine($"[log] Setting up connection to {target}...");
ws = new WebSocket(target, sslProtocols: SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls)
{
EnableAutoSendPing = true,
AutoSendPingInterval = 5
};
ws.Security.AllowNameMismatchCertificate = true;
ws.Security.AllowUnstrustedCertificate = true;
ws.DataReceived += Ws_DataReceived;
ws.Error += Ws_Error;
ws.Opened += (s, e) =>
{
ws.Send(dataBuffer, 0, dataBuffer.Length);
};
ws.Open();
}
}
}
public UserLoggedDTO LogIn(LoginDTO loginUser)
{
UserLoggedDTO userLoggedDTO = new UserLoggedDTO();
bool userLoggedIn = false;
foreach (UserDTO user in TokenContainer.GetContext().LoggedUsers.Values)
{
if (user.UserName.Equals(loginUser.UserName))
{
KeyValuePair <Guid, UserDTO> valuePair = TokenContainer.GetContext().LoggedUsers.FirstOrDefault(u => u.Value.Equals(user));
UserDTO userDTO = valuePair.Value;
userLoggedDTO.FullName = userDTO.Name + " " + userDTO.LastName;
userLoggedDTO.Role = userDTO.Role;
userLoggedDTO.Token = valuePair.Key;
userLoggedIn = true;
LogEvent log = new LoginEvent(user);
VehicleTrackingLog.GetInstance().WriteEvent(log);
}
}
if (!userLoggedIn)
{
UserDTO userDTO = this.userDAO.LogIn(loginUser);
if (userDTO == null)
{
throw new UserOrPasswordNotFoundException("El nombre de usuario o password no son correctos");
}
else
{
Guid token = Guid.NewGuid();
TokenContainer.GetContext().LoggedUsers.Add(token, userDTO);
userLoggedDTO.Token = token;
userLoggedDTO.FullName = userDTO.Name + " " + userDTO.LastName;
userLoggedDTO.Role = userDTO.Role;
LogEvent log = new LoginEvent(userDTO);
VehicleTrackingLog.GetInstance().WriteEvent(log);
}
}
return(userLoggedDTO);
}
public async Task <IActionResult> Login(User user)
{
TokenContainer token = new TokenContainer();
using (var client = new HttpClient())
{
var response = await client.PostAsJsonAsync <User>("https://localhost:44367/api/Login/", user);
if (response.IsSuccessStatusCode)
{
string apiResponse = await response.Content.ReadAsStringAsync();
token = JsonConvert.DeserializeObject <TokenContainer>(apiResponse);
configuration.GetSection("Token").Value = token.Token;
return(RedirectToAction("Index", "Home"));
}
return(View());
}
}
public async Task <JsonResult> Get(string targetUrl, dynamic data)
{
try
{
var customHeadersList = new Dictionary <string, string>();
var selectedCompany = Request.Cookies["_selected_company_"];
ITokenContainer tokenContainer = new TokenContainer();
tokenContainer.ApiSelectedCompany = selectedCompany != null?Server.UrlDecode(selectedCompany.Value) : "";
var cSelectedCompany = !string.IsNullOrEmpty(Request.Headers["_selected_company_"]) ? Request.Headers["_selected_company_"].ToString() : string.Empty;
customHeadersList.Add("_selected_company_", cSelectedCompany);
string queryString = string.Empty;
if (tokenContainer.ApiToken == null)
{
return(Json(new
{
redirectUrl = Url.Action("LogOff", "Account", new { area = string.Empty }),
isRedirect = true
}, JsonRequestBehavior.AllowGet));
}
if (!string.IsNullOrEmpty(((string[])data)[0]))
{
var dataParams = JObject.Parse(((string[])data)[0]);
List <string> properties = new List <string>();
foreach (var param in dataParams)
{
properties.Add(string.Format("{0}={1}", param.Key, HttpUtility.JavaScriptStringEncode(param.Value.Value <string>())));
}
queryString = string.Join("&", properties.ToArray());
}
ApiHelper.Client.ApiClient client = new ApiHelper.Client.ApiClient(HttpSubscriptionClient.Instance, tokenContainer);
GenericClient cb = new GenericClient(client);
var response = await cb.Get(targetUrl + "?" + queryString, customHeadersList);
return(Json(response, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
throw ex;
}
}
// GET: EmployeeInfo
public async Task <ActionResult> Index()
{
var contextWrapper = new TokenContainer();
if (contextWrapper.ApiToken != null)
{
HttpResponseMessage responseMessage = await client.GetAsync(url);
if (responseMessage.IsSuccessStatusCode)
{
var responseData = responseMessage.Content.ReadAsStringAsync().Result;
var Employees = JsonConvert.DeserializeObject <List <mstTypeOfRekanan> >(responseData);
return(View(Employees));
}
return(View("Error"));
}
return(null);
}
public async Task <JsonResult> Post(ADP.MG.Mamar.Web.Models.ApiModel apiModel)
{
ITokenContainer tokenContainer = new TokenContainer();
if (tokenContainer.ApiToken == null)
{
return(Json(new
{
redirectUrl = Url.Action("LogOff", "Account", new { area = string.Empty }),
isRedirect = true
}, JsonRequestBehavior.AllowGet));
}
var data = GetTargetData(apiModel);
ApiHelper.Client.ApiClient client = new ApiHelper.Client.ApiClient(HttpSubscriptionClient.Instance, tokenContainer);
GenericClient cb = new GenericClient(client);
var response = await cb.Post(apiModel.ApiUrl, data);
return(Json(response, JsonRequestBehavior.AllowGet));
}
public void UnregisterAll(MonoBehaviour listener)
{
char[] separator = { '/' };
string id = listener.GetInstanceID().ToString();
List <string> keysToUnsubscribe = new List <string>();
foreach (string key in _CachedTokens.Keys)
{
if (key.Split(separator)[0].Equals(id))
{
keysToUnsubscribe.Add(key);
}
}
foreach (string key in keysToUnsubscribe)
{
TokenContainer container = _CachedTokens[key];
_CachedTokens.Remove(key);
TinyMessengerHub.Instance.Unsubscribe(container.Token, container.MessageType);
}
}
public ActionResult LoginToken()
{
AuthorizationPresenter presenter = new AuthorizationPresenter();
var token = presenter.Authenticate("username", "password", "1");
if (token != null)
{
TokenContainer.SetToken(token);
}
//var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (token.HasLogin)
{
case true:
return(RedirectToAction("About", "Home"));
case false:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(RedirectToAction("Index", "Home"));
}
}
