private void UpdateStatus(ProjectLicenseGroup licenseGroup)
{
LicenseState licenseState = LicensingHelper.ProjectTypeLicense(licenseGroup, this.services);
this.currentState = this.targetState;
this.targetState = licenseState;
this.licensingAllowsNewProject = !licenseState.IsExpired;
if (this.currentState != null || this.targetState != null)
{
this.LicenseStatusText.Text = this.GenerateLicenseBarText(licenseState, licenseGroup);
}
bool flag = (this.currentState == null ? false : !this.currentState.FullyLicensed);
if (flag != (this.targetState == null ? false : !this.targetState.FullyLicensed))
{
if (!flag)
{
this.LicenseStatusBarBorder.Visibility = Visibility.Visible;
}
else
{
this.LicenseStatusBarBorder.Visibility = Visibility.Collapsed;
}
}
this.OnPropertyChanged("CanCreateNewProject");
this.OnPropertyChanged("DialogPadding");
this.OnPropertyChanged("LicenseButtonText");
this.OnPropertyChanged("LicenseButtonCommand");
}
public void ServiceInfo()
{
Service service = Connect();
ServerInfo info = service.Server.GetInfoAsync().Result;
bool dummyBool;
int dummyInt;
string[] dummyStrings;
string dummyString;
dummyInt = info.Build;
dummyString = info.CpuArchitecture;
Guid guid = info.Guid;
IReadOnlyList <string> licents = info.LicenseKeys;
IReadOnlyList <string> licentLabel = info.LicenseLabels;
dummyString = info.LicenseSignature;
LicenseState state = info.LicenseState;
Guid guid2 = info.MasterGuid;
ServerMode mode = info.Mode;
dummyString = info.OSBuild;
dummyString = info.OSName;
dummyString = info.OSVersion;
dummyString = info.ServerName;
Version version = info.Version;
dummyBool = info.IsFree;
dummyBool = info.IsRealtimeSearchEnabled;
dummyBool = info.IsTrial;
}
// Checks if license is valid for SQLsecure
// Checks ProductID, Version, Scope, Expiration, Is Duplicate
private LicenseState IsLicenseValid(BBSLic lic, string licenseKey)
{
LicenseState licState = LicenseState.InvalidKey;
if (lic != null)
{
while (licState == LicenseState.InvalidKey)
{
licState = LicenseState.Valid;
// Is the product ID for SQLsecure
if (!IsLicenseProductIDValid(lic))
{
licState = LicenseState.InvalidProductID;
break;
}
// Is this for correct version
if (!IsLicenseVersionValid(lic))
{
licState = LicenseState.InvalidProductVersion;
break;
}
// Is it registered for this repository or enterprise
if (!IsLicenseScopeValid(lic))
{
licState = LicenseState.InvalidScope;
break;
}
// Is license expired
if (lic.IsExpired)
{
licState = LicenseState.InvalidExpired;
break;
}
// Does it already exist
bool bDuplicate = false;
foreach (LicenseData licData2 in m_Licenses)
{
if (licData2.key == licenseKey)
{
bDuplicate = true;
break;
}
}
if (bDuplicate)
{
licState = LicenseState.InvalidDuplicateLicense;
}
if (!IsLicenseReasonable(lic))
{
licState = LicenseState.InvalidKey;
break;
}
}
}
return(licState);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
LicenseState state = Security.CheckLicense(LicenseFile);
// todo: show state in ui
txtRequestCode.Text = Security.GetRequestCode();
}
void ParseLicense(String text)
{
var xmlDoc = new XmlDocument()
{
PreserveWhitespace = true
};
xmlDoc.LoadXml(text);
if (!VerifySignature(xmlDoc))
{
_currentState = LicenseState.InvalidSignature;
return;
}
String dateExpired = xmlDoc.DocumentElement.GetAttribute("Expired");
if (String.IsNullOrEmpty(dateExpired))
{
_currentState = LicenseState.FileCorrupt;
return;
}
_expired = new DateTime(
Int32.Parse(dateExpired.Substring(0, 4)),
Int32.Parse(dateExpired.Substring(4, 2)),
Int32.Parse(dateExpired.Substring(6, 2))
);
if (DateTime.Today > _expired)
{
_currentState = LicenseState.Expired;
return;
}
foreach (var ch in xmlDoc.DocumentElement.ChildNodes)
{
if (ch is XmlElement xch)
{
switch (xch.Name)
{
case "Companies":
foreach (var chch in xch.ChildNodes)
{
if (chch is XmlElement xchch)
{
switch (xchch.Name)
{
case "Company":
var code = xchch.GetAttribute("Code");
var name = xchch.GetAttribute("Name");
_companies.Add(code, name);
break;
}
}
}
break;
}
}
}
}
private LicenseState LoadAndValidateLicense(string license, out BBSLic bbsLic)
{
LicenseState licState = LicenseState.InvalidKey;
bbsLic = new BBSLic();
LicErr rc = bbsLic.LoadKeyString(license);
if (rc == LicErr.OK)
{
licState = IsLicenseValid(bbsLic, license);
}
return(licState);
}
public void Initialize()
{
licState = LicenseState.InvalidKey;
numLicensedServers = 0;
isTrial = true;
licenseRepositoryID = 0;
key = string.Empty;
daysToExpireStr = string.Empty;
expirationDateStr = string.Empty;
forStr = string.Empty;
typeStr = string.Empty;
daysToExpire = 0;
isAboutToExpire = false;
}
public LicenseState CheckLicense(string autoTypeCd)
{
LicenseState lincenseState = LicenseState.Invaild;
string[] time = m_trnDate.Split('|');
if (!time.Any(s => s.Equals(DateTime.Now.ToString("yyyy-MM-dd"))))
{
lincenseState = LicenseState.Overdue;
return(lincenseState);
}
if (!m_sAutoType.Equals(autoTypeCd.Trim()))
{
lincenseState = LicenseState.AutoTypeInvaild;
return(lincenseState);
}
if (!string.IsNullOrEmpty(m_sChargeMode))
{
switch (m_sChargeMode)
{
case "Time":
{
lincenseState = (m_nTimeLmt > 0.0) ? LicenseState.Normal : LicenseState.Invaild;
break;
}
case "Mileage":
{
lincenseState = (m_fMileageLmt > 0.0) ? LicenseState.Normal : LicenseState.Invaild;
break;
}
case "Tries":
{
lincenseState = (m_nTriesLmt > 0) ? LicenseState.Normal : LicenseState.Invaild;
break;
}
default:
lincenseState = LicenseState.Invaild;
break;
}
}
else
{
throw new MissingFieldException("许可模式不能为空！");
}
return(lincenseState);
}
// Check if the given string is a valid license
// UI calls this before accepting license string
public bool IsLicenseStringValid(string license, out LicenseState licState)
{
bool bValid = false;
licState = LicenseState.InvalidKey;
if (!string.IsNullOrEmpty(license))
{
BBSLic lic = new BBSLic();
LicErr rc = lic.LoadKeyString(license);
if (rc == LicErr.OK)
{
licState = IsLicenseValid(lic, license);
bValid = licState == LicenseState.Valid ? true : false;
}
}
return(bValid);
}
public ActivationSet(string xml)
{
if (!String.IsNullOrEmpty(xml))
{
ActivationSet item = ToClass(xml);
Id = item.Id;
DateUpdated = item.DateUpdated;
MachineName = item.MachineName;
TargetType = item.TargetType;
Count = item.Count;
DateRegistered = item.DateRegistered;
Expiry = item.Expiry;
User = new UserInfo(item.User);
Sales = new PaymentInfo[item.Sales.Length];
Array.Copy(item.Sales, Sales, Sales.Length);
Setup = new InstallerInfo(item.Setup);
Status = item.Status;
}
}
public bool StartCharge(string autoType)
{
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "准备开始计费，开始检测许可信息……");
_lincenseState = _trnLicense.CheckLicense(autoType);
SqlLiteHelper.SaveTranineesInfo(_trnLicense);
if (_lincenseState == LicenseState.Normal)
{
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "该许可信息有效……");
if (_currentInfoControl == null)
{
_currentInfoControl = new ChargingControl();
_currentInfoControl.Show();
}
else
{
_currentInfoControl.Show();
}
IsChargerControlHide = false;
_chargesDisplayInfo = new ChargesInfo
{
PidNo = _trnLicense.PidNo,
Mode = _trnLicense.ChargeMode,
SeqNo = Guid.NewGuid().ToString("N").ToUpper(),
CurrentMileage = _trnLicense.MileageLmt,
CurrentMinutes = _trnLicense.TimeLmt,
SurplusTimes = _trnLicense.TriesLmt
};
_currentInfoControl.CallShowTrainerName(_trnLicense.Name);
_currentInfoControl.CallShowTrainerPhoto(_trnLicense.Photo);
_currentInfoControl.CallChangesShowInfo(_chargesDisplayInfo);
IsChargingThread = true;
Thread chargingThread = new Thread(ChargingThread);
chargingThread.Start();
return(true);
}
else
{
IsChargingThread = false;
IsCharging = false;
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "许可信息无效,失效类型：" + _lincenseState);
return(false);
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
NavFrame.Navigated += NavFrame_Navigated;
LicenseState = Security.CheckLicense(ActivationWindow.LicenseFile);
if (LicenseState == LicenseState.Illegal)
{
MessageBox.Show("软件许可出现非法状态。程序将马上退出。", "软件许可", MessageBoxButton.OK, MessageBoxImage.Stop);
App.Current.Shutdown();
}
else if (LicenseState == LicenseState.Trial)
{
ActivationWindow aw = new ActivationWindow {
Owner = this
};
aw.ShowDialog();
}
this.SetTitle();
}
public static string FormatLicenseStateDescription(LicenseState state, License license)
{
switch (state)
{
case LicenseState.NotLicensed:
return(SR.Format_LicenseState_NotLicensed);
case LicenseState.FreeFeature:
return(SR.Format_LicenseState_FreeFeature);
case LicenseState.Evaluation:
return(string.Format(CultureInfo.CurrentUICulture, SR.Format_LicenseState_Evaluation, license.Expiration));
case LicenseState.EvaluationExpired:
return(SR.Format_LicenseState_EvaluationExpired);
default:
Debug.Assert(state == LicenseState.Paid);
return(SR.Format_LicenseState_Paid);
}
}
// Check if the given string is a valid trial license
// UI calls this before accepting license string
public bool IsLicenseStringTrial(string licenseStr)
{
bool bTrial = false;
LicenseState licState = LicenseState.InvalidKey;
if (!string.IsNullOrEmpty(licenseStr))
{
BBSLic lic = new BBSLic();
LicErr rc = lic.LoadKeyString(licenseStr);
if (rc == LicErr.OK)
{
licState = IsLicenseValid(lic, licenseStr);
if (licState == LicenseState.Valid)
{
bTrial = lic.IsTrial;
}
}
}
return(bTrial);
}
public bool StartTrain(string autoType)
{
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "………………………………开始训练…………………………");
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "开启训练线程，检测许可信息……");
_lincenseState = _trnLicense.CheckLicense(autoType);
if (_lincenseState == LicenseState.Normal)
{
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":学员" + _trnLicense.PidNo + "的许可信息有效……");
ClearTrainProQueue();
IsRunning = true;
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "开启过程数据检查线程……");
Thread checkTrainProcThread = new Thread(CheckTrainProcThread);
checkTrainProcThread.Start();
return(true);
}
else
{
IsRunning = false;
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "许可信息无效，许可失效类型：" + _lincenseState);
return(false);
}
}
public XEditNetLicence(string strSavedLicense)
{
/*
* Constructor, creates and destroys the underlying real BaseLicense,
* providing access to the 3 public Members, LicenseKey, Validity and ExpiryDate
* */
try
{
LicenseBase licReal= new LicenseBase(strSavedLicense.ToUpper());
licenseKey=licReal.LicenseKey;
validity=XEditNetLicenseValidator.ValidateLicense(LicenseKey);
if ( licReal.LicenseObject.Type == LicenseType.LicenseTypes.Trial )
expiryDate=licReal.ExpiryDate.LicenseDateTime;
licReal=null;
}
catch (InvalidLicenseException)
{
validity=LicenseState.Invalid;
expiryDate=DateTime.MinValue;
}
}
void LoadLicense()
{
if (_loaded)
{
return;
}
_loaded = true;
try
{
var licText = _dbContext.Load <LicenseText>(null, "a2security.[License.Load]");
if (String.IsNullOrEmpty(licText.Text))
{
_currentState = LicenseState.NotFound;
return;
}
ParseLicense(licText.Text);
}
catch (Exception ex)
{
_lastError = ex.Message;
_currentState = LicenseState.FileCorrupt;
}
}
internal static void CheckAssertions(Database db, License license, DateTime now)
{
#if FALSE
db.SubmitChanges();
Dictionary <int, LicenseState> cache = new Dictionary <int, LicenseState>();
List <string> errors = new List <string>();
LicenseState licenseState = GetLicenseState(db, license, now, cache, errors);
if (licenseState == null)
{
throw new Exception(string.Join(". ", errors.ToArray()));
}
if (licenseState.Maximum.HasValue)
{
double max = Math.Ceiling(licenseState.Maximum.Value * (100.0 + Settings.Default.GracePeriodPercent) / 100.0);
if (licenseState.Usage > max)
{
throw new Exception("Maximum exceeded.");
}
}
#endif
}
private static LicenseState GetLicenseState(Database db, License license, DateTime?buildDate, DateTime now, Dictionary <int, LicenseState> cache, Dictionary <int, string> errors)
{
LicenseState licenseState;
if (cache.TryGetValue(license.LicenseId, out licenseState))
{
return(licenseState);
}
ParsedLicense parsedLicense = ParsedLicenseManager.GetParsedLicense(license.LicenseKey);
if (parsedLicense == null)
{
errors[license.LicenseId] = string.Format("The license key #{0} is invalid.", license.LicenseId);
return(null);
}
if (!parsedLicense.IsLicenseServerElligible())
{
errors[license.LicenseId] = string.Format("The license #{0}, of type {1}, cannot be used in the license server.",
license.LicenseId, parsedLicense.LicenseType);
return(null);
}
if (!(buildDate == null || parsedLicense.SubscriptionEndDate == null || buildDate <= parsedLicense.SubscriptionEndDate))
{
errors[license.LicenseId] = string.Format("The maintenance subscription of license #{0} ends on {1:d} but the requested version has been built on {2:d}.",
license.LicenseId, parsedLicense.SubscriptionEndDate, buildDate);
return(null);
}
licenseState = new LicenseState(now, db, license, parsedLicense);
cache.Add(license.LicenseId, licenseState);
return(licenseState);
}
public XEditNetLicence(string strSavedLicense)
{
/*
* Constructor, creates and destroys the underlying real BaseLicense,
* providing access to the 3 public Members, LicenseKey, Validity and ExpiryDate
* */
try
{
LicenseBase licReal = new LicenseBase(strSavedLicense.ToUpper());
licenseKey = licReal.LicenseKey;
validity = XEditNetLicenseValidator.ValidateLicense(LicenseKey);
if (licReal.LicenseObject.Type == LicenseType.LicenseTypes.Trial)
{
expiryDate = licReal.ExpiryDate.LicenseDateTime;
}
licReal = null;
}
catch (InvalidLicenseException)
{
validity = LicenseState.Invalid;
expiryDate = DateTime.MinValue;
}
}
private void CheckTrainProcThread()
{
bool canGo = false;
bool isEnd = false;
while (IsRunning)
{
if (_trainProcQueue.Count > 0)
{
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "发现" + _trainProcQueue.Count + "条过程数据，开始处理……");
TrainProc tp;
if (!_trainProcQueue.TryDequeue(out tp) || tp == null)
{
throw new InvalidOperationException("队列处理失败");
}
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "过程数据:" + tp.Code + "," + tp.Type);
if (tp.Code == "10000" && tp.Type == "S")
{
cacheTime = 0;
detailTime = 0;
detailMileage = 0;
detailTries = 0;
startTime = DateTime.Now;
canGo = true;
isEnd = false;
if (_trnLicense.TrainDetail == null)
{
_trnLicense.TrainDetail = new TrainDetail
{
TrainStartTs = startTime
};
}
else
{
detailMileage = _trnLicense.TrainDetail.TrainMileage;
detailTime = _trnLicense.TrainDetail.TrainTime;
detailTries = _trnLicense.TrainDetail.TrainTries;
}
if (_trnLicense.TrainDetail.TrainProcList == null)
{
_trnLicense.TrainDetail.TrainProcList = new List <TrainProc>();
}
SaveTrainingInfo(tp);
SqlLiteHelper.SaveChargesInfo(_chargesDisplayInfo);
SqlLiteHelper.SaveTraningInfo(_trnLicense);
writeToDisk();
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "过程数据为10000，状态为S,初始化状态信息……");
IsCharging = true;
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "状态信息初始化完毕，开启训练线程……");
continue;
}
if (!canGo)
{
if (tp.Code == "10000" && tp.Type == "T")
{
StopCharging();
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "训练未开始，关闭训练！");
}
else
{
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "训练未开始，当前数据无效，已丢弃！");
}
continue;
}
if (tp.Code == "10000" && tp.Type == "T")
{
if (!IsRunning)
{
continue;
}
if (_trnLicense.TrainDetail != null)
{
_trnLicense.TrainDetail.TrainEndTs = DateTime.Now;
}
_lincenseState = LicenseState.Invaild;
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + @"过程数据为10000，状态为T,准备保存状态信息……");
SaveTrainingInfo(tp);
StopTrain(true);
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "本次状态信息保存完毕，关闭训练界面，返回验证界面……");
continue;
}
if (tp.Code == "10000" && tp.Type == "E")
{
if (!isEnd)
{
isEnd = true;
SaveTrainingInfo(tp);
if (_trnLicense.ChargeMode == "Tries")
{
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + @"过程数据为10000，状态为E,计费模式为[次数]，检查许可信息……");
if (_trnLicense.TriesLmt <= 0)
{
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "训练次数为0，停止计费……");
StopCharging();
if (StopDelegate != null)
{
StopDelegate();
}
continue;
}
}
StopCharging();
_sw.WriteLine(DateTime.Now.ToLocalTime() + ":" + "本次训练过程信息保存完毕，本次训练结束……");
}
continue;
}
SaveTrainingInfo(tp);
SqlLiteHelper.SaveChargesInfo(_chargesDisplayInfo);
SqlLiteHelper.SaveTraningInfo(_trnLicense);
writeToDisk();
}
Thread.Sleep(100);
}
}
/// <summary>
/// Creates a new <see cref="TradeSharpLicense"/> object.
/// </summary>
private TradeSharpLicense()
{
_licenseState = VerifyLicense() ? LicenseState.Active : LicenseState.Expired;
}
/// <summary>
/// Creates a new <see cref="TradeSharpLicense"/> object.
/// </summary>
private TradeSharpLicense(LicenseType licenseType, LicenseState licenseState)
{
_licenseType = licenseType;
_licenseState = licenseState;
}
private static LicenseState GetLicenseState(Database db, License license, DateTime? buildDate, DateTime now, Dictionary<int, LicenseState> cache, Dictionary<int, string> errors)
{
LicenseState licenseState;
if (cache.TryGetValue(license.LicenseId, out licenseState))
return licenseState;
ParsedLicense parsedLicense = ParsedLicenseManager.GetParsedLicense(license.LicenseKey);
if (parsedLicense == null)
{
errors[license.LicenseId] = string.Format("The license key #{0} is invalid.", license.LicenseId);
return null;
}
if (!parsedLicense.IsLicenseServerElligible())
{
errors[license.LicenseId] = string.Format("The license #{0}, of type {1}, cannot be used in the license server.",
license.LicenseId, parsedLicense.LicenseType);
return null;
}
if ( !(buildDate == null || parsedLicense.SubscriptionEndDate == null || buildDate <= parsedLicense.SubscriptionEndDate ) )
{
errors[license.LicenseId] = string.Format("The maintenance subscription of license #{0} ends on {1:d} but the requested version has been built on {2:d}.",
license.LicenseId, parsedLicense.SubscriptionEndDate, buildDate);
return null;
}
licenseState = new LicenseState(now, db, license, parsedLicense);
cache.Add(license.LicenseId, licenseState);
return licenseState;
}
private string GenerateLicenseBarText(LicenseState state, ProjectLicenseGroup licenseGroup)
{
string licenseWpfSilverlightAuthoringNeedsActivation;
string licenseSilverlightMobileAuthoringNeedsActivation;
string licenseSketchFlowAuthoringNeedsActivation;
string empty = string.Empty;
if (!state.FullyLicensed)
{
switch (licenseGroup)
{
case ProjectLicenseGroup.WpfSilverlight:
{
if (state.IsLicensed)
{
licenseWpfSilverlightAuthoringNeedsActivation = StringTable.LicenseWpfSilverlightAuthoringNeedsActivation;
}
else if (state.IsExpired)
{
licenseWpfSilverlightAuthoringNeedsActivation = StringTable.LicenseWpfSilverlightAuthoringTrialExpired;
}
else if (state.DaysLeft == 1)
{
licenseWpfSilverlightAuthoringNeedsActivation = StringTable.LicenseWpfSilverlightAuthoringTrialDaysLeftSingular;
}
else
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
string licenseWpfSilverlightAuthoringTrialDaysLeftPlural = StringTable.LicenseWpfSilverlightAuthoringTrialDaysLeftPlural;
object[] daysLeft = new object[] { state.DaysLeft };
licenseWpfSilverlightAuthoringNeedsActivation = string.Format(currentCulture, licenseWpfSilverlightAuthoringTrialDaysLeftPlural, daysLeft);
}
empty = licenseWpfSilverlightAuthoringNeedsActivation;
break;
}
case ProjectLicenseGroup.SilverlightMobile:
{
if (state.IsLicensed)
{
licenseSilverlightMobileAuthoringNeedsActivation = StringTable.LicenseSilverlightMobileAuthoringNeedsActivation;
}
else if (state.IsExpired)
{
licenseSilverlightMobileAuthoringNeedsActivation = StringTable.LicenseSilverlightMobileAuthoringTrialExpired;
}
else if (state.DaysLeft == 1)
{
licenseSilverlightMobileAuthoringNeedsActivation = StringTable.LicenseSilverlightMobileAuthoringTrialDaysLeftSingular;
}
else
{
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
string licenseSilverlightMobileAuthoringTrialDaysLeftPlural = StringTable.LicenseSilverlightMobileAuthoringTrialDaysLeftPlural;
object[] objArray = new object[] { state.DaysLeft };
licenseSilverlightMobileAuthoringNeedsActivation = string.Format(cultureInfo, licenseSilverlightMobileAuthoringTrialDaysLeftPlural, objArray);
}
empty = licenseSilverlightMobileAuthoringNeedsActivation;
break;
}
case ProjectLicenseGroup.SketchFlow:
{
if (state.IsLicensed)
{
licenseSketchFlowAuthoringNeedsActivation = StringTable.LicenseSketchFlowAuthoringNeedsActivation;
}
else if (state.IsExpired)
{
licenseSketchFlowAuthoringNeedsActivation = StringTable.LicenseSketchFlowAuthoringTrialExpired;
}
else if (state.DaysLeft == 1)
{
licenseSketchFlowAuthoringNeedsActivation = StringTable.LicenseSketchFlowAuthoringTrialDaysLeftSingular;
}
else
{
CultureInfo currentCulture1 = CultureInfo.CurrentCulture;
string licenseSketchFlowAuthoringTrialDaysLeftPlural = StringTable.LicenseSketchFlowAuthoringTrialDaysLeftPlural;
object[] daysLeft1 = new object[] { state.DaysLeft };
licenseSketchFlowAuthoringNeedsActivation = string.Format(currentCulture1, licenseSketchFlowAuthoringTrialDaysLeftPlural, daysLeft1);
}
empty = licenseSketchFlowAuthoringNeedsActivation;
break;
}
}
}
return(empty);
}
protected INamedProject InitializeProject(IProjectStore projectStore)
{
INamedProject namedProject;
INamedProject unlicensedProject = null;
try
{
IProjectType projectTypeForProject = this.Services.ProjectTypeManager().GetProjectTypeForProject(projectStore);
if (projectTypeForProject != null)
{
IProjectCreateError projectCreateError = projectTypeForProject.CanCreateProject(projectStore);
if (projectCreateError != null)
{
projectTypeForProject = this.Services.ProjectTypeManager().UnknownProjectType;
}
if (projectTypeForProject is UnknownProjectType && SolutionBase.IsReloadPromptEnabled())
{
InvalidProjectStore invalidProjectStore = projectStore as InvalidProjectStore;
if (invalidProjectStore == null || string.IsNullOrEmpty(invalidProjectStore.InvalidStateDescription))
{
this.PromptWithUnsupportedProjectDetails(projectStore, projectCreateError);
}
else
{
IMessageDisplayService messageDisplayService = this.Services.MessageDisplayService();
ErrorArgs errorArg = new ErrorArgs();
CultureInfo currentUICulture = CultureInfo.CurrentUICulture;
string unsupportedProjectWithDescription = StringTable.UnsupportedProjectWithDescription;
object[] displayName = new object[] { projectStore.DocumentReference.DisplayName, invalidProjectStore.InvalidStateDescription };
errorArg.Message = string.Format(currentUICulture, unsupportedProjectWithDescription, displayName);
errorArg.AutomationId = "OpenProjectErrorDialog";
messageDisplayService.ShowError(errorArg);
}
}
LicenseState licenseState = LicensingHelper.IsProjectLicensed(projectStore, this.serviceProvider);
if (!licenseState.IsExpired)
{
if (!licenseState.FullyLicensed)
{
LicensingHelper.UnlicensedProjectLoadAttempted();
}
unlicensedProject = projectTypeForProject.CreateProject(projectStore, this.GetCodeDocumentTypeFromProject(projectStore), this.serviceProvider);
}
else
{
LicensingHelper.UnlicensedProjectLoadAttempted();
unlicensedProject = new UnlicensedProject(projectStore, this.serviceProvider);
}
return(unlicensedProject);
}
else
{
namedProject = null;
}
}
catch (Exception exception)
{
if (unlicensedProject != null)
{
projectStore.Dispose();
unlicensedProject.Dispose();
unlicensedProject = null;
}
throw;
}
return(namedProject);
}
public Lease GetLease(Database db, string productCode, Version version, DateTime?buildDate, string machine, string userName, string authenticatedUserName, DateTime now, Dictionary <int, string> errors, License[] licenses)
{
Dictionary <int, LicenseState> licenseStates = new Dictionary <int, LicenseState>();
Settings settings = Settings.Default;
// Check if we have a lease that we can use.
foreach (License license in licenses)
{
LicenseState licenseState = GetLicenseState(db, license, version, buildDate, now, licenseStates, errors);
if (licenseState == null)
{
continue;
}
int licenseId = license.LicenseId;
Lease[] currentLeases = (from l in db.OpenLeases
where
l.LicenseId == licenseId &&
l.StartTime <= now &&
l.EndTime > now &&
l.UserName == userName
orderby l.StartTime
select l).ToArray();
Dictionary <string, string> machines = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (Lease candidateLease in currentLeases)
{
machines[candidateLease.Machine] = candidateLease.Machine;
if (candidateLease.Machine != machine)
{
continue;
}
if (candidateLease.EndTime > now.AddDays(settings.MinLeaseDays))
{
// We have already a good lease.
return(candidateLease);
}
else
{
// Invariant: we can always prolong a lease because licenses are always acquired from
// the present moment, therefore taking the current lease into account.
// UNLESS it's the end of the license period or the grace period.
Lease lease = db.ProlongLease(candidateLease, authenticatedUserName, now);
if (lease == null)
{
continue;
}
return(lease);
}
}
// We did not find a lease for the requested machines.
// See if we can do a new lease that would not increment the number of concurrent users.
if (machines.Count % Settings.Default.MachinesPerUser != 0)
{
CheckAssertions(db, license, now);
Lease lease = db.CreateLease(license, userName, machine, authenticatedUserName, now, licenseState.InExcess);
if (lease != null)
{
return(lease);
}
}
}
// We don't have a current lease. Create a new one.
foreach (License license in licenses)
{
LicenseState licenseState = GetLicenseState(db, license, version, buildDate, now, licenseStates, errors);
if (licenseState == null)
{
continue;
}
if (licenseState.Maximum.HasValue && licenseState.Maximum.Value <= licenseState.Usage &&
(!licenseState.ParsedLicense.ValidTo.HasValue || now < licenseState.ParsedLicense.ValidTo))
{
// Not enough users for this license.
continue;
}
Lease lease = db.CreateLease(license, userName, machine, authenticatedUserName, now, false);
if (lease != null)
{
return(lease);
}
}
// We did not find a suitable license. See if we can use the grace period.
foreach (License license in licenses)
{
LicenseState licenseState = GetLicenseState(db, license, version, buildDate, now, licenseStates, errors);
if (licenseState == null)
{
continue;
}
if (license.GraceStartTime == null)
{
license.GraceStartTime = now;
}
int graceLimit = (int)Math.Ceiling(licenseState.Maximum.Value * (100.0 + licenseState.ParsedLicense.GetGracePercentOrDefault()) / 100.0);
DateTime graceEnd = license.GraceStartTime.Value.AddDays(licenseState.ParsedLicense.GetGraceDaysOrDefault());
if (license.GraceStartTime <= now && graceEnd > now && licenseState.Usage < graceLimit)
{
// We will use the grace period.
// See if we should send a warning message.
if (license.GraceLastWarningTime.GetValueOrDefault(DateTime.MinValue).AddDays(settings.GracePeriodWarningDays) < now)
{
try
{
string body = string.Format(
"The license #{0} has a capacity of {1} concurrent user(s), but {2} users are currently using the product {3}. " +
"The grace period has started on {4} and will end on {5}. After this date, additional leases will be denied." +
"Please contact PostSharp Technologies to acquire additional licenses.",
license.LicenseId, licenseState.Maximum, licenseState.Usage + 1, licenseState.ParsedLicense.Product,
license.GraceStartTime, graceEnd);
const string subject = "WARNING: licensing capacity exceeded";
SendEmail(settings.GracePeriodWarningEmailTo, settings.GracePeriodWarningEmailCC, subject, body);
license.GraceLastWarningTime = now;
}
catch (Exception e)
{
Trace.TraceError(e.ToString());
}
}
Lease lease = db.CreateLease(license, userName, machine, authenticatedUserName, now, true);
if (lease != null)
{
return(lease);
}
}
}
SendEmail(settings.DeniedRequestEmailTo, null, "ERROR: license request denied",
string.Format("No license with free capacity was found to satisfy the lease request for the product {0} from " +
"the user '{1}' (authentication: '{2}'), machine '{3}'. " + string.Join(". ", errors.ToArray()),
productCode, userName, authenticatedUserName, machine));
return(null);
}
public License()
{
State = LicenseState.Trial;
Expire = DateTime.Now.AddDays(15);
Times = 15;
}
public LicenseValidationFailedException(LicenseState licenseState)
{
state = licenseState;
}
private static LicenseState GetLicenseState(Database db, License license, Version version, DateTime?buildDate, DateTime now, Dictionary <int, LicenseState> cache, Dictionary <int, string> errors)
{
LicenseState licenseState;
if (cache.TryGetValue(license.LicenseId, out licenseState))
{
return(licenseState);
}
ParsedLicense parsedLicense = ParsedLicenseManager.GetParsedLicense(license.LicenseKey);
if (parsedLicense == null)
{
errors[license.LicenseId] = string.Format("The license key #{0} is invalid.", license.LicenseId);
return(null);
}
if (parsedLicense.MinPostSharpVersion > ApplicationInfo.Version)
{
errors[license.LicenseId] = string.Format(
"The license #{0} requires higher version of PostSharp on the License Server. Please upgrade PostSharp NuGet package of the License Server to >= {1}.{2}.{3}",
license.LicenseId,
parsedLicense.MinPostSharpVersion.Major,
parsedLicense.MinPostSharpVersion.Minor,
parsedLicense.MinPostSharpVersion.Build);
return(null);
}
if (parsedLicense.MinPostSharpVersion > version)
{
errors[license.LicenseId] = string.Format(
"The license #{0} of type {1} requires PostSharp version >= {2}.{3}.{4} but the requested version is {5}.{6}.{7}.",
license.LicenseId,
parsedLicense.LicenseType,
parsedLicense.MinPostSharpVersion.Major,
parsedLicense.MinPostSharpVersion.Minor,
parsedLicense.MinPostSharpVersion.Build,
version.Major,
version.Minor,
version.Build);
return(null);
}
if (!parsedLicense.IsLicenseServerEligible())
{
errors[license.LicenseId] = string.Format("The license #{0}, of type {1}, cannot be used in the license server.",
license.LicenseId, parsedLicense.LicenseType);
return(null);
}
if (!(buildDate == null || parsedLicense.SubscriptionEndDate == null || buildDate <= parsedLicense.SubscriptionEndDate))
{
// PostSharp version number has been introduced in the license server protocol in PostSharp v5.
if (version.Major >= 5)
{
errors[license.LicenseId] = string.Format(
"The maintenance subscription of license #{0} ends on {1:d} but the requested version {2}.{3}.{4} has been built on {5:d}.",
license.LicenseId,
parsedLicense.SubscriptionEndDate,
version.Major,
version.Minor,
version.Build,
buildDate);
}
else
{
errors[license.LicenseId] = string.Format(
"The maintenance subscription of license #{0} ends on {1:d} but the requested version has been built on {2:d}.",
license.LicenseId,
parsedLicense.SubscriptionEndDate,
buildDate);
}
return(null);
}
licenseState = new LicenseState(now, db, license, parsedLicense);
cache.Add(license.LicenseId, licenseState);
return(licenseState);
}
