internal static MapModule[] GetModuleFeatures(ViewAccountProduct product, List <AccountProductModuleModel> modules)
{
if (object.Equals(_moduleFeaturesMap, null))
{
return(null);
}
Version productVersion;
Version.TryParse(product.ProductVersion, out productVersion);
var mapStrategy = product.IsPPC ? MapStrategy.PerpetualLicense : MapStrategy.Subscription;
var moduleFeatures = _moduleFeaturesMap.GetModules(mapStrategy, productVersion);
if (!object.Equals(modules, null) && !object.Equals(moduleFeatures, null))
{
foreach (var module in modules)
{
var moduleFeature = moduleFeatures.FirstOrDefault(e => string.Equals(e.Name, module.Module, StringComparison.InvariantCultureIgnoreCase));
if (!object.Equals(moduleFeature, null))
{
moduleFeature.ActivateFeatures();
}
}
}
return(moduleFeatures);
}
public static int ProductEndDateComparer(ViewAccountProduct p1, ViewAccountProduct p2)
{
if (p1.EndDate.HasValue && p2.EndDate.HasValue)
{
return(p1.EndDate.Value.CompareTo(p2.EndDate.Value) * -1);
}
return(0);
}
public static AccountProductViewModel AccountProductConvertor(ViewAccountProduct product)
{
var newProduct = new AccountProductViewModel();
newProduct = Mapper.Map(product, newProduct);
foreach (var module in newProduct.Modules.Where(e => "e-sign".Equals(e.Module, StringComparison.InvariantCultureIgnoreCase)))
{
module.Allowed = product.AllowedEsignCount;
module.Used = product.UsedEsignCount;
}
return(newProduct);
}
internal static Guid?GetAllowedAccountProductId(List <ViewAccountProduct> products, Guid?accountProductId, out ViewAccountProduct product)
{
var sorted = products.OrderByDescending(e => e.PurchaseDate);
var filter = sorted.Where(e => !e.IsDisabled);
product =
filter.FirstOrDefault(e => !e.AllowedEsignCount.HasValue && accountProductId.HasValue && e.AccountProductId == accountProductId.Value) ??
filter.FirstOrDefault(e => !e.AllowedEsignCount.HasValue && e.IsMinor) ??
filter.FirstOrDefault(e => e.AllowedEsignCount.HasValue && e.IsMinor && e.AllowedEsignCount > e.UsedEsignCount);
if (!object.Equals(product, null))
{
return(product.AccountProductId);
}
return(null);
}
internal virtual async Task <bool> ValidateAccountSystemAsync(Account user, SessionToken session, ViewAccountProduct product)
{
return(await Task.FromResult(true));
}
internal virtual bool ValidateSessionTokenAsync(Account user, IEnumerable <SessionToken> sessions, SessionToken session, ViewAccountProduct product)
{
return(true);
}
internal override async Task <bool> ValidateAccountSystemAsync(Account account, SessionToken session, ViewAccountProduct product)
{
if (!product.IsPPC)
{
return(await Task.FromResult(true));
}
var accountSystems = await Auth.AccountSystemsGetAsync(new AccountProductPair(account.Id, product.AccountProductId));
var accountSystemsWithoutCurrent = accountSystems.Where(e => e.SystemId != session.SystemId.Value);
var limit = 1;
//if user's license associated more than {{limit}} devices
return(await Task.FromResult(accountSystemsWithoutCurrent.Count() < limit));
}
internal override bool ValidateSessionTokenAsync(Account user, IEnumerable <SessionToken> sessions, SessionToken session, ViewAccountProduct product)
{
var accountProductSessions = sessions.Where(e => (e.AccountProductId.HasValue && e.AccountProductId.Value == product.AccountProductId && e.SystemId.HasValue && e.SystemId.Value != session.SystemId.Value) ||
(e.Id == session.Id));
var limit = 3;
#if PdfSam
limit = 2;
#endif
#if LuluSoft
if (product.IsFree)
{
limit = 10;
}
#endif
//if user is logged into more than {{limit}} devices
return(accountProductSessions.Count() <= limit);
}
internal async Task <IHttpActionResult> PostToken(List <ViewAccountProduct> products, ViewAccountProduct product,
List <SessionToken> sessions, SessionToken session,
Account user, AuthenticationTicket ticket)
{
if (object.Equals(product, null))
{
return(ProductNotFound());
}
var scopeWorker = SaaSScopeWorkerFactory.Create(session.Scope, _auth, _authProduct);
if (!scopeWorker.ValidateSessionTokenAsync(user, sessions, session, product))
{
return(ErrorContent("invalid_grant", "You are logged into too many devices.", HttpStatusCode.Conflict));
}
if (!await scopeWorker.ValidateAccountSystemAsync(user, session, product))
{
return(ErrorContent("invalid_grant", "Your license is currently associated with another device.", HttpStatusCode.Conflict));
}
var modules = UserManagerHelper.GetAllowedModules(products, product.AccountProductId, ticket.Identity);
var activeProducts = UserManagerHelper.GetActiveProducts(products, modules, product.AccountProductId);
var moduleFeatures = AccountController.GetModuleFeatures(product, modules);
var client = GetClient(session.ClientId);
var oldId = OauthManager.UpdateTicket(user, session, ticket, product, client);
await _auth.SessionTokenInsertAsync(session, oldId, false, product.IsPPC);
return(Ok(OauthManager.ReleaseToken(session, ticket, modules, moduleFeatures, activeProducts, user)));
}
public static int OrderComparer(ViewAccountProduct p1, ViewAccountProduct p2)
{
if (object.Equals(p1, null) && object.Equals(p2, null))
{
return(0);
}
if (object.Equals(p1, null))
{
return(-1);
}
if (object.Equals(p2, null))
{
return(1);
}
if (p1.IsDisabled && p2.IsDisabled)
{
return(ProductEndDateComparer(p1, p2));
}
if (p1.IsDisabled)
{
return(-1);
}
if (p2.IsDisabled)
{
return(1);
}
if (!p1.IsActive && p2.IsActive)
{
return(-1);
}
if (p1.IsActive && !p2.IsActive)
{
return(1);
}
if ((p1.IsRenewal && !p1.NextRebillDate.HasValue) && (p2.IsRenewal && !p2.NextRebillDate.HasValue))
{
return(ProductEndDateComparer(p1, p2));
}
if ((p1.IsRenewal && !p1.NextRebillDate.HasValue) && !(p2.IsRenewal && !p2.NextRebillDate.HasValue))
{
return(1);
}
if (!(p1.IsRenewal && !p1.NextRebillDate.HasValue) && (p2.IsRenewal && !p2.NextRebillDate.HasValue))
{
return(-1);
}
if (p1.IsMinor && p2.IsMinor)
{
return(ProductEndDateComparer(p1, p2));
}
if (p1.IsMinor && !p2.IsMinor)
{
return(-1);
}
if (!p1.IsMinor && p2.IsMinor)
{
return(1);
}
if (p1.IsPPC && !p2.IsPPC)
{
return(-1);
}
if (!p1.IsPPC && p2.IsPPC)
{
return(1);
}
var count1 = object.Equals(p1.Modules, null) ? 0 : p1.Modules.Count;
var count2 = object.Equals(p2.Modules, null) ? 0 : p2.Modules.Count;
if (count1 == count2)
{
return(ProductEndDateComparer(p1, p2));
}
return(count1.CompareTo(count2));
}
internal static Guid UpdateTicket(Account user, SessionToken session, AuthenticationTicket ticket, ViewAccountProduct product, Client client)
{
var currentSessionId = session.Id;
session.Id = Guid.NewGuid();
var timeSpan = session.ExpiresUtc - session.IssuedUtc;
var issued = DateTime.UtcNow;
session.IssuedUtc = issued;
session.ExpiresUtc = issued.Add(timeSpan);
ticket.Properties.IssuedUtc = session.IssuedUtc;
ticket.Properties.ExpiresUtc = session.ExpiresUtc;
ticket.Properties.Dictionary["session"] = session.Id.ToString("N");
ticket.Identity.AddClaims(user, client);
session.ProtectedTicket = Startup.OAuthBearerOptions.AccessTokenFormat.Protect(ticket);
session.AccountProductId = product.AccountProductId;
return(currentSessionId);
}
