public async Task <IActionResult> CreateToken(CreateTokenModel model)
{
var user = await _context.Users
.Include(u => u.UserRoles)
.ThenInclude(ur => ur.Role)
.FirstOrDefaultAsync(u => u.EmailAddress == model.EmailAddress);
if (user == null)
{
return(Generate(HttpStatusCode.BadRequest, "The credentials provided were invalid."));
}
var verified = _hashService.VerifyHash(model.Password, user.Password);
if (!verified)
{
return(Generate(HttpStatusCode.BadRequest, "The credentials provided were invalid."));
}
if (user.IsLockedOut)
{
return(Generate(HttpStatusCode.BadRequest, "This account has been locked out, please try again later."));
}
var result = _jwtService.GenerateToken(user);
return(Generate(HttpStatusCode.OK, result));
}
public static IEnumerable <ValidationResult> Validate(this CreateTokenModel requestData)
{
var validationResults = new List <ValidationResult>();
validationResults.AddRange(ClassValidator <CreateTokenModel> .Validate(requestData));
validationResults.AddRange(ClassValidator <TransactionModel> .Validate(requestData.Transaction ?? new TransactionModel()));
foreach (var service in requestData.Services ?? new List <ServiceModel>())
{
validationResults.AddRange(ClassValidator <ServiceModel> .Validate(service));
}
foreach (var allocation in requestData.Allocations ?? new List <AllocationModel>())
{
validationResults.AddRange(ClassValidator <AllocationModel> .Validate(allocation));
}
foreach (var traveler in requestData.Travelers ?? new List <TravelerModel>())
{
validationResults.AddRange(ClassValidator <TravelerModel> .Validate(traveler));
}
return(validationResults);
}
public ActionResult GenerateToken(CreateTokenModel createTokenModel)
{
Person person = (Person)Session["Persons"];
ViewBag.JourneyStart = new SelectList(railwayDbContexts.City, "CityName", "CityName");
ViewBag.JourneyEnd = new SelectList(railwayDbContexts.City, "CityName", "CityName");
bool isExist = createTokenModel.isAlreadyPurchseToday(createTokenModel.JourneyDate, person.PersonID);
if (isExist)
{
if (ModelState.IsValid)
{
createTokenModel.personID = Convert.ToInt32(Session["ID"]);
Session["CreateToken"] = createTokenModel;
createTokenModel.insertData(createTokenModel);
Journey journey = createTokenModel.GetDetails();
UpdateTicketStatusTotalToPending(journey.CoatchType);
return(View("FullTicket", journey));
}
return(View("GenerateToken"));
}
else
{
ModelState.AddModelError("JourneyDate", "You have already purchase a ticket today. Please select another date");
return(View("GenerateToken"));
}
}
public IHttpActionResult Post([FromBody] CreateTokenModel model)
{
using (var t = Repository.BeginTransaction())
{
var authToken = AuthTokenService.Create(model.Username, model.Password);
t.Commit();
return(Json(Mapper.Map <AuthTokenCreateView>(authToken)));
}
}
public void Post([FromBody] CreateTokenModel model)
{
//TODO:
var adService = new AdService();
var valid = adService.ValidateCredentials(model.Login, model.Password);
//generate token
//return token
}
public ActionResult GenerateToken(CreateTokenModel createTokenModel)
{
createTokenModel.personID = Convert.ToInt32(Session["ID"]);
Session["CreateToken"] = createTokenModel;
createTokenModel.insertData(createTokenModel);
Journey journey = createTokenModel.GetDetails();
UpdateTicketStatusTotalToPending(journey.CoatchType);
return(View("FullTicket", journey));
}
public virtual async Task <Status> RequestAuthorization(SecurityManagerClient secMgr, ApplicationManagerClient appMgr, IdentityManagerClient idMgr, string userID, string enterpriseID, string hostName)
{
// Create an access request
var accessRequest = new AccessRequest()
{
User = userID,
EnterpriseID = enterpriseID
};
// Create JToken to attached to metadata model
var model = new MetadataModel();
model.Metadata.Add(new KeyValuePair <string, JToken>("AccessRequest", JToken.Parse(Newtonsoft.Json.JsonConvert.SerializeObject(accessRequest))));
// Create token model - is including the access request payload redundant??
var tokenModel = new CreateTokenModel()
{
Payload = model,
UserEmail = userID,
OrganizationID = enterpriseID,
Encrypt = true
};
// Encrypt user email and enterpries ID, generate token
var response = await secMgr.CreateToken("RequestAccessToken", tokenModel);
// Build grant/deny links and text body
if (response != null)
{
string grantLink = $"<a href=\"{hostName}/grant/token?={response.Model}\">Grant Access</a>";
string denyLink = $"<a href=\"{hostName}/deny/token?={response.Model}\">Deny Access</a>";
string emailHtml = $"A user has requested access to this Organization : {grantLink} {denyLink}";
// Send email from app manager client
var email = new AccessRequestEmail()
{
Content = emailHtml,
EmailFrom = "*****@*****.**",
EmailTo = "*****@*****.**",
User = userID,
Subject = "Access authorization requested",
EnterpriseID = enterpriseID
};
var emailModel = new MetadataModel();
model.Metadata.Add(new KeyValuePair <string, JToken>("AccessRequestEmail", JToken.Parse(JsonConvert.SerializeObject(email))));
appMgr.SendAccessRequestEmail(model, enterpriseID);
}
// If successful, adjust state to reflect that a request was sent for this enterprise by this user
return(Status.Success);
}
public IActionResult Create([FromBody] CreateTokenModel createTokenModel)
{
IActionResult response = Unauthorized();
var newToken = Authenticate(createTokenModel);
if (newToken != null)
{
response = Ok(newToken);
}
return(response);
}
public async Task <IActionResult> CreateToken([FromBody] CreateTokenModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ApiResponse.FromError(MemzError.FromModelState(ModelState))));
}
if (!await Repository.RepositoryExists(model.Repository))
{
return(BadRequest(
ApiResponse.FromMemzException(
new MemzException(
MemzErrorCode.RepositoryNotFound,
$"Repository {model.Repository} not found"
)
)
));
}
try
{
await Repository.GetRepositoryMasterKey(model.Repository, model.Passphrase);
}
catch (MemzException ex) when(ex.ErrorCode == MemzErrorCode.IntegrityCheckFailed)
{
return(BadRequest(ApiResponse.FromMemzException(new MemzException(MemzErrorCode.InvalidPassphrase, "Invalid repository passphrase"))));
}
var jwt = new JwtSecurityTokenHandler();
var key = Configuration.GetIssuerSigningKey();
var serverKey = Configuration.GetServerKey();
var encryptedPassphrase = CryptoService.PassphraseEncrypt(serverKey, Encoding.UTF8.GetBytes(model.Passphrase));
var tok = jwt.CreateToken(new()
{
Issuer = jwtOptions.TokenValidationParameters.ValidIssuer,
Audience = jwtOptions.TokenValidationParameters.ValidAudience,
Expires = DateTime.UtcNow.AddHours(1),
Subject = new ClaimsIdentity(new Claim[]
{
new(Const.RepositoryNameClaimType, model.Repository),
new(Const.EncryptedPassphraseClaimType, encryptedPassphrase.ToString()),
}),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha512Signature)
});
private TokenModel Authenticate(CreateTokenModel createTokenModel)
{
var newToken = _tokenService.CreateNewToken(new CreateTokenViewModel()
{
IntegrationKey = createTokenModel.IntegrationKey
});
if (newToken == null)
{
return(null);
}
return(new TokenModel()
{
Key = newToken.Key,
DueDate = newToken.DueDate
});
}
public DetailsOfFullTicket GetTicketDetails()
{
DetailsOfFullTicket detailsOfFullTicket = new DetailsOfFullTicket();
CreateTokenModel tokenDetails = (CreateTokenModel)Session["CreateToken"];
Person personDetsils = (Person)Session["Persons"];
TicketConfirmField ticketConfirmField = (TicketConfirmField)Session["TicketConfirmField"];
detailsOfFullTicket.PersonName = personDetsils.PersonName;
detailsOfFullTicket.PersonFathersName = personDetsils.PersonFathersName;
detailsOfFullTicket.PersonAddress = personDetsils.PersonAddress;
detailsOfFullTicket.CoatchType = tokenDetails.CoatchType;
detailsOfFullTicket.BogyName = ticketConfirmField.BogyName;
detailsOfFullTicket.SeatNumber = ticketConfirmField.SeatNumber;
detailsOfFullTicket.NumberOfSeat = ticketConfirmField.NumberOfSeat;
detailsOfFullTicket.JourneyStart = tokenDetails.JourneyStart;
detailsOfFullTicket.JourneyEnd = tokenDetails.JourneyEnd;
detailsOfFullTicket.JourneyDate = tokenDetails.JourneyDate.ToShortDateString();
detailsOfFullTicket.TimeOfJourney = tokenDetails.TimeOfJourney;
return(detailsOfFullTicket);
}
/// <inheritdoc />
public CreateTokenResponse CreateToken(CreateTokenModel requestData)
{
var validationResults = requestData.Validate().ToList();
if (validationResults.Any())
{
return(new CreateTokenResponse
{
Result = "-99",
ResultExplanation = validationResults.Select(x => x.ErrorMessage).Aggregate((i, j) => i + "," + j)
});
}
var xml = CreateTokenRequestXml.Get(_companyToken, requestData);
//Get the response
var responseXml = _url.PostXmlToUrl(xml).AddResultExplanationCdata(_bypassCdataMod);
var response = responseXml.FromXml <CreateTokenResponse>();
Debug.WriteLine(response);
return(response);
}
public void CreateTokenTest(string name, string surname, string email)
{
var service = new DirectPayService(_baseUrl, _companyToken);
var data = new CreateTokenModel
{
Customer = new CustomerModel
{
CustomerFirstName = name,
CustomerLastName = surname,
CustomerPhone = "",
CustomerEmail = email
},
Transaction = new TransactionModel
{
CompanyRef = Guid.NewGuid().ToString("N"),
PaymentAmount = decimal.Parse($"{rnd.Next(11, 199)}.{rnd.Next(0, 99)}"),//TODO: Set Transaction Payment Amount here
Currency = Currencies.USD,
TransactionChargeType = "1"
},
Services = new List <ServiceModel>
{
new ServiceModel
{
ServiceDescription = "Service Here", //TODO: Get your service from DPO
ServiceType = 0, //TODO: Get your service type from DPO
ServiceDate = DateTime.Now
}
}
};
var response = service.CreateToken(data);
_debug.WriteLine("Result: {0}", response.Result);
_debug.WriteLine("Result Explanation: {0}", response.ResultExplanation);
_debug.WriteLine("Transaction Token: {0} - Amount: {1}", response.TransToken, data.Transaction.PaymentAmount);
Assert.Equal(true, response.Result == "000");
}
public static string Get(string companyToken, CreateTokenModel model)
{
var xmlDocument = new XDocument(new XDeclaration("1.0", "utf-8", "no"));
var root = new XElement("API3G",
new XElement("CompanyToken", companyToken),
new XElement("Request", RequestTypes.CreateToken)
);
var transaction = new XElement("Transaction",
new XElement("PaymentAmount", model.Transaction.PaymentAmount),
new XElement("PaymentCurrency", model.Transaction.Currency),
new XElement("CompanyRef", model.Transaction.CompanyRef),
//new XElement("CompanyRefUnique", model.Transaction.CompanyRefUnique),
new XElement("TransactionChargeType", model.Transaction.TransactionChargeType)
);
if (!string.IsNullOrWhiteSpace(model.Transaction.RedirectUrl))
{
transaction.Add(new XElement("RedirectURL", model.Transaction.RedirectUrl));
}
if (!string.IsNullOrWhiteSpace(model.Transaction.BackUrl))
{
transaction.Add(new XElement("BackURL", model.Transaction.BackUrl));
}
if (!string.IsNullOrWhiteSpace(model.Transaction.DeclinedUrl))
{
transaction.Add(new XElement("DeclinedURL", model.Transaction.DeclinedUrl));
}
if (!string.IsNullOrWhiteSpace(model.Customer?.CustomerEmail ?? ""))
{
transaction.Add(new XElement("customerEmail", model.Customer?.CustomerEmail));
}
root.Add(transaction);
var services = new XElement("Services");
foreach (var service in model.Services)
{
services.Add(new XElement("Service",
new XElement("ServiceType", service.ServiceType),
new XElement("ServiceDescription", service.ServiceDescription),
new XElement("ServiceDate", service.ServiceDate.ToString("yyyy/MM/dd HH:MM"))
));
}
root.Add(services);
if (model.Allocations.Any())
{
var allocations = new XElement("Allocations");
root.Add(allocations);
}
if (model.Travelers.Any())
{
var travelers = new XElement("Travelers");
root.Add(travelers);
}
xmlDocument.Add(root);
using (var sw = new Utf8StringWriter())
{
xmlDocument.Save(sw, SaveOptions.None);
return(sw.ToString());
}
}
