public void SendActivationRequest(ActivationRequest activationRequest)
{
Template activationTemplate = _templateRepository.Get("ActivationTemplate.html");
string notification = activationTemplate.Apply(activationRequest.ToDictionary());
_notificationSender.SendNotification(notification, activationRequest.Email.Value);
}
public ActivationResponse Activate(string[] barcodes)
{
using (var client = new HttpClient())
{
var url = $"{ConfigurationManager.AppSettings["EnterativeActivationApi"]}";
var request = new ActivationRequest
{
ActivationType = "VIRTUAL",
Merchant = ConfigurationManager.AppSettings["EnterativeMerchant"],
Shop = ConfigurationManager.AppSettings["EnterativeShop"],
Terminal = ConfigurationManager.AppSettings["EnterativeTerminal"],
CallbackURL = ConfigurationManager.AppSettings["EnterativeCallBackUrl"],
Lines = barcodes.Select(b =>
new Line
{
Barcode = b,
ExternalCode = $"WOW-{DateTime.Now:yyyyMMddhhmmddss}"
}).ToList()
};
var xml = request.ToString();
using (var stringContent = new StringContent(xml, Encoding.UTF8, "application/json"))
{
var resp = client.PostAsync(url, stringContent).Result;
resp.EnsureSuccessStatusCode();
var jsonResult = resp.Content.ReadAsStringAsync().Result;
var response = JsonConvert.DeserializeObject <ActivationResponse>(jsonResult);
if (response.Response != "E00")
{
throw new Exception($"ERRO AO CHAMAR API DE ATIVAÇÃO ENTERATIVE - CODIGO {response.Response}");
}
return(response);
}
}
}
/// <summary>
/// Validates the Given OTP
/// </summary>
/// <returns></returns>
public static string ValidateForActivation(ActivationRequest inputuser, User dbUser, bool isResetPwd)
{
String statusMsg = string.Empty;
if (dbUser.IsActivated && !isResetPwd)
{
statusMsg = ErrorCodes.USER_ALREADY_ACTIVATED.ToString();
}
else if (HttpUtility.HtmlDecode(dbUser.OTPCode) != inputuser.OTPCode)
{
statusMsg = ErrorCodes.INVALID_OTP_CODE.ToString();
}
else if (DateTimeOffset.UtcNow > dbUser.OTPGeneratedAt.Value.AddMinutes(Convert.ToInt64(ConfigurationManager.AppSettings[Constants.OTP_TIME_CONN_STRING])))
{
statusMsg = ErrorCodes.OTP_EXPIRED.ToString();
}
else if (!dbUser.IsActivated && isResetPwd)
{
statusMsg = ErrorCodes.USER_NOT_ACVTD.ToString();
}
else if (dbUser != null && dbUser.Domain.IsActive == false)
{
statusMsg = ErrorCodes.DOMAIN_IS_INACTIVE.ToString();
}
else
{
statusMsg = Constants.SUCCESS_MSG;
}
return(statusMsg);
}
public override async Task <ActivationReply> ActivateUser(ActivationRequest request, ServerCallContext context)
{
try
{
var op = await dataAccess.GetUserByEmail(request.Email);
if (op != null && op.otp == request.ActivationKey)
{
if (await dataAccess.ActivateUser(op.userID))
{
return(new ActivationReply {
ErrorCode = ErrorCode.Success
});
}
}
return(new ActivationReply {
ErrorCode = ErrorCode.Fail
});
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return(new ActivationReply {
ErrorCode = ErrorCode.FailUnknown
});
}
}
/// <summary>
/// Activates a License
/// the License must be valid and non activated
/// there can only be one activation of a SerialNumber
/// If the Activation is successful the SerialNumber and ActivationKey will be inserted into the local database.
/// It will throw a ActivationFailedException if the ManastoneServer delivers no or an empty Offer.
/// </summary>
/// <param name="req">an ActivationRequest containing the SerialNumber and the CPU1 ID</param>
private void Activate(ActivationRequest req)
{
try
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "req " + req.SerialNumber +
" " + req.ProductUUID + " " + req.HardwareId); //DEBUG
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "Start");
var activationKey =
SocketIoClient.RetrieveSingleValue <ActivationOffer>(_url, "ActivationOffer", "ActivationRequest",
req.Serialize(), timeout: _timeout);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "ActivationOffer " + activationKey.ActivationKey.Length);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "ActivationOffer " + activationKey.Serialize());
if (activationKey.ActivationKey.Length == 0)
{
throw new ActivationFailedException("Length == 0");
}
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "Before SerialInsertion");
_database.InsertSerialNumber(req.SerialNumber);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "Before ActivationKeyInsertion");
_database.InsertActivationKey(req.SerialNumber, activationKey.ActivationKey);
RetrieveToken(new TokenRequest(activationKey.ActivationKey));
RetrieveCustomerReference(new CustomerReferenceRequest(activationKey.ActivationKey));
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "Complete");
_database.Log.ProcessLogList();
}
catch (Exception e)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmError, "ERROR on ACTIVATE", e.Message);
_database.Log.ProcessLogList();
throw new ActivationFailedException();
}
}
public async Task <ActivationResponse> ActivateAsync(string token)
{
var request = new ActivationRequest
{
Token = token
};
var result = await HttpClient.PostAsJsonAsync("api/Player/Activate", request);
return(await EnsureApiResult <ActivationResponse>(result));
}
public void RequestActivationKey(List <CheckableDataGridViewRow> rowsChecked)
{
List <Host> checkedHosts = RowsToHosts(rowsChecked.ConvertAll(r => r as LicenseDataGridViewRow));
ActivationRequest.Hosts = checkedHosts;
using (MemoryStream ms = ActivationRequest.CreateRequestBestEffort())
{
ActivationRequestCommand activationRequestCommand = new ActivationRequestCommand(CommandInterface, ActivationRequest.RequestEncoding.GetString(ms.ToArray()));
activationRequestCommand.Execute();
}
}
public ActivationResponse Activate(ActivationRequest request)
{
var token = request.Token;
var activated = _commands.ActivateViaEmail(token);
return(new ActivationResponse
{
Activated = activated,
Token = token
});
}
public object Put(ActivationRequest request)
{
try
{
IntegrationService.Reset();
}
catch (Exception ex)
{
return(ServerError(ex.Message));
}
return(OK());
}
public ActivationResponse ActivateUser(ActivationRequest req)
{
req.ActivationCode = Cryptography.Decrypt(req.ActivationCode);
UserActivation UserAction = _context.UserActivations.Include(x => x.User)
.Where(p => p.ActivationCode == req.ActivationCode && p.ActivationType == ActivationType.UserActivation)
.Select(s => s).FirstOrDefault();
UserAction.User.Active = true;
UserAction.isActivated = true;
UserAction.ActivationChannelType = ActivationChannelType.Email;
_context.SaveChangesAsync();
return(UserAction.Adapt <ActivationResponse>());
}
public async Task <PID?> GetAsync(ClusterIdentity clusterIdentity, CancellationToken ct)
{
ct = CancellationTokens.WithTimeout(_getPidTimeout);
//Get address to node owning this ID
var identityOwner = _partitionManager.Selector.GetIdentityOwner(clusterIdentity.Identity);
Logger.LogDebug("Identity belongs to {address}", identityOwner);
if (string.IsNullOrEmpty(identityOwner))
{
return(null);
}
var remotePid = PartitionManager.RemotePartitionIdentityActor(identityOwner);
var req = new ActivationRequest
{
ClusterIdentity = clusterIdentity
};
Logger.LogDebug("Requesting remote PID from {Partition}:{Remote} {@Request}", identityOwner, remotePid, req
);
try
{
var resp = await _cluster.System.Root.RequestAsync <ActivationResponse>(remotePid, req, ct);
return(resp.Pid);
}
//TODO: decide if we throw or return null
catch (DeadLetterException)
{
Logger.LogInformation("Remote PID request deadletter {@Request}, identity Owner {Owner}", req, identityOwner);
return(null);
}
catch (TimeoutException)
{
Logger.LogInformation("Remote PID request timeout {@Request}, identity Owner {Owner}", req, identityOwner);
return(null);
}
catch (Exception e)
{
Logger.LogError(e, "Error occured requesting remote PID {@Request}, identity Owner {Owner}", req, identityOwner);
return(null);
}
}
public IHttpActionResult ForgotPassword(ActivationRequest request)
{
try
{
var user = DbUtilities.GetUserByEmail(request.Email);
if (user != null)
{
string validStatus = ValidationUtilities.ValidateForActivation(request, user, true);
if (validStatus == Constants.SUCCESS_MSG)
{
User account = _context.Users.Where(a => a.Email == request.Email).SingleOrDefault();
//if (IsPasswordCorrect(request.Password, account))
// return BadRequest(ErrorCodes.PASSWORD_ALREADY_USED.ToString());
byte[] pwdhash = AuthorizationUtilities.hash(request.Password, account.Salt);
// account.UpdatedAt = DateTime.UtcNow;
account.ModifiedBy = request.Email;
account.IsActivated = true;
account.OTPCode = "";
//add the new password to the database
account.Password = pwdhash;
account.PwdStartDate = DateTimeOffset.UtcNow;
account.IsLocked = false;
_context.SaveChanges();
return(Ok(HttpUtilities.CustomResp(ErrorCodes.PWD_UPDATED.ToString())));
}
else
{
return(BadRequest(validStatus));
}
}
else
{
//user doesn't exists
return(BadRequest(ErrorCodes.INVALID_USER.ToString()));
}
}
catch (Exception ex)
{
LGSELogger.Error(ex);
return(InternalServerError(ex));
}
}
public IHttpActionResult ActivateUser(ActivationRequest request)
{
try
{
var dbUser = DbUtilities.GetUserByEmail(request.Email);
if (dbUser != null)
{
string validStatus = DbUtilities.ValidateForActivation(request, dbUser, false);
if (validStatus == Constants.SUCCESS_MSG)
{
//Need to get Oorg id based on domain
byte[] salt = AuthorizationUtilities.generateSalt();
User account = _context.Users.SingleOrDefault(a => a.Email == request.Email);
// account.UpdatedAt = DateTime.UtcNow;
account.ModifiedBy = request.Email;
account.Salt = salt;
account.Password = AuthorizationUtilities.hash(request.Password, salt);
account.IsActivated = true;
account.OTPCode = "";
_context.SaveChanges();
return(Ok(HttpUtilities.CustomResp(ErrorCodes.USER_ACTIVATED.ToString())));
}
else
{
return(BadRequest(validStatus));
}
}
else
{
return(BadRequest(ErrorCodes.INVALID_USER.ToString()));
}
}
catch (Exception ex)
{
LGSELogger.Error(ex);
return(InternalServerError(ex));
}
}
public static string GetActivationRequest(string licenseKey, string productId, List <ActivationMetadata> metadata, List <ActivationMeterAttribute> meterAttributes)
{
var activationRequest = new ActivationRequest();
activationRequest.Fingerprint = LexSystemInfo.GetFingerPrint();
activationRequest.ProductId = productId;
activationRequest.Key = licenseKey;
activationRequest.Os = LexSystemInfo.GetOsName();
activationRequest.OsVersion = LexSystemInfo.GetOsVersion();
activationRequest.UserHash = LexEncryptionService.Sha256(LexSystemInfo.GetUser());
activationRequest.AppVersion = LexDataStore.AppVersion;
activationRequest.ClientVersion = LexDataStore.ClientVersion;
activationRequest.VmName = LexSystemInfo.GetVmName();
activationRequest.Hostname = LexSystemInfo.GetHostname();
activationRequest.Email = String.Empty;
activationRequest.Password = String.Empty;
activationRequest.Metadata = metadata;
activationRequest.MeterAttributes = meterAttributes;
string jsonBody = JsonConvert.SerializeObject(activationRequest);
return(jsonBody);
}
public void DumpState(ClusterIdentity clusterIdentity)
{
Console.WriteLine("Memberlist members:");
_cluster.MemberList.DumpState();
Console.WriteLine("Partition manager selector:");
_partitionManager.Selector.DumpState();
//Get address to node owning this ID
var identityOwner = _partitionManager.Selector.GetIdentityOwner(clusterIdentity.Identity);
Console.WriteLine("Identity owner for ID:");
Console.WriteLine(identityOwner);
var remotePid = PartitionManager.RemotePartitionIdentityActor(identityOwner);
var req = new ActivationRequest
{
ClusterIdentity = clusterIdentity
};
var resp = _cluster.System.Root.RequestAsync <ActivationResponse>(remotePid, req, CancellationTokens.WithTimeout(5000)).Result;
Console.WriteLine("Target Pid:");
if (resp == null)
{
Console.WriteLine("Null response");
}
else if (resp.Pid == null)
{
Console.WriteLine("Null PID");
}
else
{
Console.WriteLine(resp.Pid);
}
}
public Response <ActivationResponse> ActivationBackLink(ActivationRequest req)
{
Response <ActivationResponse> _response = new Response <ActivationResponse>();
try
{
_response.RequestState = true;
if (ModelState.IsValid)
{
_response.Data = _userManager.ActivateUser(req);
}
else
{
_response.ErrorState = true;
_response.StatusCode = HttpStatusCode.BadRequest;
}
}
catch (Exception ex)
{
_response.ErrorState = true;
_response.ErrorList.Add(ex.Adapt <ApiException>());
}
return(_response);
}
public object Put(ActivationRequest request)
{
try
{
IntegrationService.Reset();
}
catch (Exception ex)
{
return ServerError(ex.Message);
}
return OK();
}
public Task <ActivationResponse> ActivateCard(ActivationRequest request)
{
throw new System.NotImplementedException();
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "v1/ActivateLicense")] HttpRequest req,
ILogger log)
{
try
{
var conn = System.Environment.GetEnvironmentVariable("MongoDBConnectionString");
var client = new MongoClient(conn);
var dbName = System.Environment.GetEnvironmentVariable("license_management_db");
var database = client.GetDatabase(dbName);
var collection = database.GetCollection <ActivationRequest>(
System.Environment.GetEnvironmentVariable("activation_requests_col")
);
var licenses_col = database.GetCollection <License>(
System.Environment.GetEnvironmentVariable("licenses_col")
);
var activationcodes_col = database.GetCollection <ActivationCode>(
System.Environment.GetEnvironmentVariable("activation_codes_col")
);
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
ActivationRequest activationRequest = JsonConvert.DeserializeObject <ActivationRequest>(requestBody);
activationRequest.RequestDate = DateTime.UtcNow;
var findActivationCodeResult = activationcodes_col.Find(q => q.GuidCode == activationRequest.ActivationCode).ToList();
//Activation Code not exists, then do nothing
if (findActivationCodeResult.Count == 0)
{
activationRequest.Status = "Failed";
activationRequest.ActivationResult = "Activation code not exists.";
await collection.InsertOneAsync(activationRequest);
BasicResponse response = new BasicResponse();
response.Status = "OK";
response.Code = "Failed";
response.Message = "Activation code could not be validated.";
return(new OkObjectResult(response));
}
License license = new License();
license.ActivationCode = activationRequest.ActivationCode;
var findLicensesResult = licenses_col.Find(q => q.ActivationCode == license.ActivationCode).ToList();
if (findLicensesResult.Count > 0)
{
// Greater than 0 means there is a license assined
activationRequest.Status = "Failed";
activationRequest.ActivationResult = "Activation code is already assigned";
await collection.InsertOneAsync(activationRequest);
BasicResponse response = new BasicResponse();
response.Status = "OK";
response.Code = "Failed";
response.Message = "License could not be activated.";
return(new OkObjectResult(response));
}
else
{
// 0 means there is not a license assined
ActivationCode activationCode = findActivationCodeResult[0];
List <string> activationSettings_ValueList = activationRequest.ActivationSettings.GetValueList();
// Generate hash only for settings
string license_hashsettings = Crypto.concatenate_sha256_hash(activationSettings_ValueList);
activationSettings_ValueList.Add(activationRequest.ActivationCode);
// Generate hash adding activation code for generate license code
activationRequest.ActivationSettings.HashSettings = Crypto.concatenate_sha256_hash(activationSettings_ValueList);
license.LicenseHash = activationRequest.ActivationSettings.HashSettings;
license.LicenseSettings = new LicenseSettings();
license.LifeTime = activationCode.LifeTime;
license.Type = activationCode.LicenseType;
license.LicenseSettings.Company = activationRequest.ActivationSettings.Company;
license.LicenseSettings.CustomerCode = activationRequest.ActivationSettings.CustomerCode;
license.LicenseSettings.Email = activationRequest.ActivationSettings.Email;
license.LicenseSettings.HardwareId = activationRequest.ActivationSettings.HardwareId;
license.LicenseSettings.Location = activationRequest.ActivationSettings.Location;
license.ActivationDate = DateTime.UtcNow;
license.LicenseSettings.HashSettings = license_hashsettings;
license.Status = "Active";
await licenses_col.InsertOneAsync(license);
activationRequest.Status = "Success";
activationRequest.ActivationResult = "License has been assigned and activated.";
await collection.InsertOneAsync(activationRequest);
LicenseActivationSuccessResponse response = new LicenseActivationSuccessResponse();
response.Status = "OK";
response.Code = "Success";
response.Message = "License has been assigned and activated.";
response.LicenseCode = license.LicenseHash;
return(new OkObjectResult(response));
}
}
catch (System.Exception e)
{
BasicResponse response = new BasicResponse();
response.Status = "OK";
response.Code = "Excepcion";
response.Message = e.Message;
return(new OkObjectResult(response));
}
}
public Task <ActivationResponse> RegisterAndActivateCard(ActivationRequest request)
{
return(_cardManagementRepository.ActivateCard(request));
}
