/// <summary>
/// Creates reminding whith custom text.
/// </summary>
/// <param name="remindingText">Text to be shown in reminding</param>
protected virtual void CreateReminding(string remindingText)
{
Reminding remindingEntity = new Reminding(_userConnection);
var manager = _userConnection.GetSchemaManager("EntitySchemaManager");
var targetSchema = manager.FindItemByName(_schemaName);
manager = _userConnection.GetSchemaManager("ClientUnitSchemaManager");
var loaderSchema = manager.FindItemByName("DuplicatesSearchNotificationTargetLoader");
string subject = _schemaName;
DateTime userDateTime = _userConnection.CurrentUser.GetCurrentDateTime();
Guid userContactId = _userConnection.CurrentUser.ContactId;
var condition = new Dictionary <string, object> {
{
"Author", userContactId
}, {
"Contact", userContactId
}, {
"Source", RemindingConsts.RemindingSourceAuthorId
}, {
"SubjectCaption", subject
}, {
"SysEntitySchema", targetSchema.UId
},
};
string description = GetRemindingDescription(_userConnection);
string hash = GetRemindingHash(condition);
if (!string.IsNullOrEmpty(remindingText))
{
subject = GetRemindingSubject(_userConnection, _schemaName, remindingText);
}
if (!remindingEntity.FetchFromDB(new Dictionary <string, object> {
{ "Hash", hash }
}, false))
{
remindingEntity.SetDefColumnValues();
}
remindingText = TruncateString(remindingText, DescriptionTypeStringLength);
subject = TruncateString(subject, SubjectCaptionTypeStringLength);
remindingEntity.SetColumnValue("ModifiedOn", userDateTime);
remindingEntity.SetColumnValue("AuthorId", userContactId);
remindingEntity.SetColumnValue("ContactId", userContactId);
remindingEntity.SetColumnValue("SourceId", RemindingConsts.RemindingSourceAuthorId);
remindingEntity.SetColumnValue("RemindTime", userDateTime);
remindingEntity.SetColumnValue("Description", description);
remindingEntity.SetColumnValue("SubjectCaption", subject);
remindingEntity.SetColumnValue("NotificationTypeId", RemindingConsts.NotificationTypeNotificationId);
remindingEntity.SetColumnValue("Hash", hash);
remindingEntity.SetColumnValue("SysEntitySchemaId", targetSchema.UId);
remindingEntity.SetColumnValue("LoaderId", loaderSchema.UId);
remindingEntity.SetColumnValue("IsRead", false);
remindingEntity.Save();
}
/// <summary>
/// Reports manager warmup.
/// </summary>
/// <param name="userConnection">User connection instance.</param>
public static void WarmupReports(UserConnection userConnection)
{
#if !NETSTANDARD2_0 // TODO CRM-42452
WarmupManager <ReportSchemaManager, Terrasoft.Reports.ReportSchema>(userConnection
.GetSchemaManager(typeof(ReportSchemaManager).Name));
#endif
}
public virtual string GetSerializedString()
{
var manager = UserConnection.GetSchemaManager("EntitySchemaManager") as Terrasoft.Core.Entities.EntitySchemaManager;
var entitySchema = manager.GetInstanceByUId(StoringEntitySchemaId);
Entity entity = entitySchema.CreateEntity(UserConnection);
var valueColumn = entitySchema.Columns.GetByUId(StoringColumnUId);
if (entity.FetchFromDB(entitySchema.GetPrimaryColumnName(), StoringPrimaryColumnValue))
{
using (MemoryStream stream = entity.GetStreamValue(valueColumn.ColumnValueName)){
if (stream != null)
{
stream.Position = 0;
return(Terrasoft.Common.StreamUtilities.GetStreamContent(stream));
}
else
{
return(String.Empty);
}
}
}
else
{
return(String.Empty);
}
}
public virtual void SetDefaultSysMsgUserSettings()
{
var entitySchemaManager = UserConnection.GetSchemaManager("EntitySchemaManager") as EntitySchemaManager;
EntitySchema wSysAccountSchema = entitySchemaManager.GetInstanceByName("WSysAccount");
Entity wSysAccountEntity = wSysAccountSchema.CreateEntity(UserConnection);
EntitySchema sysMsgUserSettingsSchema = entitySchemaManager.GetInstanceByName("SysMsgUserSettings");
Entity sysMsgUserSettingsEntity = sysMsgUserSettingsSchema.CreateEntity(UserConnection);
sysMsgUserSettingsEntity.SetDefColumnValues();
sysMsgUserSettingsEntity.SetColumnValue("UserId", Entity.PrimaryColumnValue);
sysMsgUserSettingsEntity.SetColumnValue("SysMsgLibId", WebitelSymMsgLibId);
Dictionary <string, object> connectionParamsDictionary = new Dictionary <string, object>()
{
{ "isWrapUpDisabled", false },
{ "debugMode", false },
{ "disableCallCentre", false },
{ "isAutoLogin", true },
{ "useWebitelCti", false },
{ "useWebPhone", true },
{ "useVideo", false }
};
string connectionParams = ServiceStackTextHelper.Serialize(connectionParamsDictionary);
sysMsgUserSettingsEntity.SetColumnValue("ConnectionParams", connectionParams);
sysMsgUserSettingsEntity.Save();
}
private void SetAccountSchemaUid()
{
var manager = UserConnection.GetSchemaManager("EntitySchemaManager");
var account = manager.FindItemByName("Account");
accountSchemaUId = Column.Parameter(account.UId);
}
public static string GetVideoCode(string helpContextId, UserConnection userConnection)
{
var entitySchemaManager = userConnection.GetSchemaManager("EntitySchemaManager") as EntitySchemaManager;
var videoHelpSchemaQuery = new EntitySchemaQuery(entitySchemaManager, "VideoHelp");
videoHelpSchemaQuery.Cache = userConnection.SessionCache.WithLocalCaching(TSConfiguration.CacheUtilities.GlobalModuleCacheGroup);
var videoIdField = videoHelpSchemaQuery.AddColumn("Id");
var helpContextIdField = videoHelpSchemaQuery.AddColumn("HelpContextId");
var videoCodeField = videoHelpSchemaQuery.AddColumn("VideoCode");
videoHelpSchemaQuery.Filters.Add(videoHelpSchemaQuery.CreateFilterWithParameters(FilterComparisonType.Equal, helpContextIdField.Name, helpContextId));
videoHelpSchemaQuery.CacheItemName = "VideoHelpContextId_" + helpContextId;
var videoCollection = videoHelpSchemaQuery.GetEntityCollection(userConnection);
string videoCode = "";
if (videoCollection.Count > 0)
{
videoCode = videoCollection[0].GetTypedColumnValue <string>(videoCodeField.Name);
if (!string.IsNullOrEmpty(videoCode))
{
HasVideoCode = true;
}
else
{
HasVideoCode = false;
}
}
else
{
HasVideoCode = false;
}
return(videoCode);
}
private void SetContactSchemaUid()
{
var manager = UserConnection.GetSchemaManager("EntitySchemaManager");
var contact = manager.FindItemByName("Contact");
contactSchemaUId = Column.Parameter(contact.UId);
}
private Guid GetSysProcessLogUId()
{
var manager = UserConnection.GetSchemaManager("EntitySchemaManager");
var sysProcessLog = manager.FindItemByName("SysProcessLog");
return(sysProcessLog.UId);
}
private void StartCampaign(CoreCampaignSchema campaignSchema, DateTime scheduledFireTime)
{
var schemaManager = (CampaignSchemaManager)_userConnection.GetSchemaManager("CampaignSchemaManager");
ChangeStatusToActive(campaignSchema.UId);
schemaManager.ActualizeCampaignSchemaInfo(campaignSchema, _userConnection);
LogAction(campaignSchema.EntityId, CampaignConsts.CampaignLogTypeCampaignStart);
RunCampaign(campaignSchema, CampaignSchemaExecutionStrategy.DefaultPeriod, scheduledFireTime);
}
/// <summary>
/// Schedule next job for the specified campaign.
/// </summary>
/// <param name="campaignSchemaUId">The unique identifier of campaign schema instance.</param>
/// <param name="fireTimeConfig">Fire time config for job.</param>
public void ScheduleJob(Guid campaignSchemaUId, CampaignFireTimeConfig fireTimeConfig)
{
try {
var schemaManager = (CampaignSchemaManager)_userConnection.GetSchemaManager("CampaignSchemaManager");
CoreCampaignSchema campaignSchema = schemaManager.GetSchemaInstance(campaignSchemaUId);
ScheduleJob(campaignSchema, fireTimeConfig);
} catch (Exception ex) {
string message = CampaignHelper.GetLczStringValue(nameof(CampaignJobDispatcher),
"ScheduleBySchemaUIdException");
Logger.ErrorFormat(message, ex, campaignSchemaUId);
throw;
}
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
var pageSchemaManager = UserConnection.GetSchemaManager("PageSchemaManager") as PageSchemaManager;
var pageSchema = pageSchemaManager.GetInstanceByName("SocialAccountAuthPage");
var sb = new StringBuilder();
sb.AppendFormat("Terrasoft.openWindow('ViewPage.aspx','{0}',", pageSchema.UId.ToString());
// params:
sb.Append("[");
bool isFirst = true;
var parameters = new Dictionary <string, string> {
{ "userId", UserId.ToString() },
{ "SocialNetwork", SocialNetwork },
{ "OpenerPageId", OpenerPageId },
{ "SuccessEventName", SuccessEventName },
{ "FailedEventName", FailedEventName }
};
foreach (var parameter in parameters)
{
if (isFirst)
{
isFirst = false;
}
else
{
sb.Append(",\n\t");
}
sb.Append("{");
sb.AppendFormat("\tname: '{0}',", parameter.Key);
sb.AppendFormat("\tvalue: '{0}'", parameter.Value);
sb.Append("}");
}
sb.Append("\t],");
var width = pageSchema.Width.ToString(CultureInfo.InvariantCulture);
var height = pageSchema.Height.ToString(CultureInfo.InvariantCulture);
sb.AppendFormat("{0}, {1}, ", width, height);
// isCenterWindow:
sb.Append("true);");
var page = (System.Web.HttpContext.Current.CurrentHandler as Terrasoft.UI.WebControls.Page).Page;
ScriptManager scriptManager = page.FindControl("ScriptManager") as Terrasoft.UI.WebControls.Controls.ScriptManager;
string script = sb.ToString();
scriptManager.AddScript(script);
return(true);
}
/// <summary>
/// Returns <see cref="EntityCollection"/> of <see cref="ContactCommunication"/> by email address.
/// </summary>
/// <param name="userConnection"><see cref="UserConnection"/> instance.</param>
/// <param name="email">Email address.</param>
/// <param name="contactIdQueryColumnName">Contact id query column name.</param>
/// <param name="contactNameQueryColumnName">Contact name query column name.</param>
/// <returns><see cref="EntityCollection"/> of <see cref="ContactCommunication"/>.</returns>
private static EntityCollection GetContactCommunicationsByEmail(UserConnection userConnection, string email,
out string contactIdQueryColumnName, out string contactNameQueryColumnName)
{
var entitySchemaManager = userConnection.GetSchemaManager("EntitySchemaManager") as EntitySchemaManager;
var contactCommunicationSchemaQuery = new EntitySchemaQuery(entitySchemaManager, "ContactCommunication");
contactIdQueryColumnName = contactCommunicationSchemaQuery.AddColumn("Contact.Id").Name;
contactNameQueryColumnName = contactCommunicationSchemaQuery.AddColumn("Contact.Name").Name;
contactCommunicationSchemaQuery.AddColumn("Contact.CreatedOn").OrderByAsc();
var filter = contactCommunicationSchemaQuery.CreateFilterWithParameters(FilterComparisonType.Equal, "Number",
email);
contactCommunicationSchemaQuery.Filters.Add(filter);
return(contactCommunicationSchemaQuery.GetEntityCollection(userConnection));
}
private CoreEntitySchema GetExtendedBaseVisaEntitySchema()
{
var entitySchemaManager = _userConnection.GetSchemaManager("EntitySchemaManager") as EntitySchemaManager;
var baseVisaEntitySchema = entitySchemaManager.GetInstanceByName("BaseVisa");
CoreEntitySchema baseVisaSchema = new CoreEntitySchema(baseVisaEntitySchema, false);
baseVisaSchema.AddColumn("LongText", "Title");
baseVisaSchema.AddColumn("LongText", "VisaSchemaName");
baseVisaSchema.AddColumn("Guid", "VisaObjectId");
baseVisaSchema.AddColumn("Guid", "VisaSchemaTypeId");
baseVisaSchema.AddColumn("LongText", "VisaTypeName");
baseVisaSchema.AddColumn("LongText", "VisaSchemaCaption");
baseVisaSchema.AddColumn("LongText", "SchemaName");
return(baseVisaSchema);
}
public virtual void UpdateData(string serializedString)
{
Stream stream = new MemoryStream(UTF8Encoding.UTF8.GetBytes(serializedString));
stream.Position = 0;
var manager = UserConnection.GetSchemaManager("EntitySchemaManager") as Terrasoft.Core.Entities.EntitySchemaManager;
var entitySchema = manager.GetInstanceByUId(StoringEntitySchemaId);
Entity entity = entitySchema.CreateEntity(UserConnection);
var valueColumn = entitySchema.Columns.GetByUId(StoringColumnUId);
if (entity.FetchFromDB(entitySchema.GetPrimaryColumnName(), StoringPrimaryColumnValue))
{
entity.SetStreamValue(valueColumn.ColumnValueName, stream);
entity.Save();
}
}
/// <summary>
/// Schedules next campaign job if it is possible.
/// </summary>
/// <param name="userConnection">The user connection.</param>
/// <param name="campaignSchemaUId">Unique identifier of campaign schema.</param>
/// <param name="scheduledDate">Time of the previous campaign run.
/// It can be null when need calculate next fire time relatively to current time.</param>
/// <returns>Returns true when campaign job is scheduled.</returns>
public virtual bool TryScheduleNextJob(UserConnection userConnection, Guid campaignSchemaUId,
DateTime?scheduledDate)
{
_userConnection = userConnection;
try {
var schemaManager =
(CampaignSchemaManager)_userConnection.GetSchemaManager(nameof(CampaignSchemaManager));
CoreCampaignSchema campaignSchema = schemaManager.GetSchemaInstance(campaignSchemaUId);
return(TryScheduleNextJob(campaignSchema, scheduledDate));
} catch (Exception e) {
string message = string.Format(CampaignHelper
.GetLczStringValue(nameof(CampaignJobExecutor), "ScheduleNextJobError"), campaignSchemaUId);
Logger.Error(message, e);
return(false);
}
}
/// <summary>
/// Returns next fire time for campaign.
/// When <paramref name="previousScheduledFireTime"/> is null then used
/// <see cref="DateTime.UtcNow"/> as benchmark point for calculation.
/// </summary>
/// <param name="campaignId">Campaign identifier.</param>
/// <param name="useCurrentUserTimezone">Flag that indicates add current user
/// timezone offset to next campaign scheduled time(in UTC) or not.</param>
/// <param name="previousScheduledFireTime">Time of the previous campaign run.
/// It can be null when need calculate next fire time relatively current time.</param>
/// <returns>Returns campaign's next run time.</returns>
public DateTime GetCampaignNextFireTime(Guid campaignId, bool useCurrentUserTimezone,
DateTime?previousScheduledFireTime = null)
{
var schemaUid = GetCampaignSchemaUid(campaignId);
var benchmarkTime = previousScheduledFireTime ?? new DateTime(CurrentTime.Year, CurrentTime.Month,
CurrentTime.Day, CurrentTime.Hour, CurrentTime.Minute, 0, DateTimeKind.Utc);
var schemaManager = (CampaignSchemaManager)_userConnection.GetSchemaManager("CampaignSchemaManager");
CoreCampaignSchema campaignSchema = schemaManager.GetSchemaInstance(schemaUid);
var scheduledUtcFireTime = GetNextFireTime(campaignSchema, benchmarkTime);
if (useCurrentUserTimezone)
{
return(scheduledUtcFireTime.Time.AddMinutes(UserTimeZoneOffset.TotalMinutes));
}
return(scheduledUtcFireTime.Time);
}
public virtual void LoadMenu()
{
var menu = Menu as Terrasoft.UI.WebControls.Controls.MenuBaseCollection;
if (menu != null)
{
var appCache = UserConnection.SessionCache.WithLocalCaching(TSConfiguration.CacheUtilities.WorkspaceCacheGroup);
var reportsCollection = Terrasoft.Configuration.CommonUtilities.GetSelectData(UserConnection, Terrasoft.Configuration.CommonUtilities.GetModuleReportsSelect, appCache, TSConfiguration.CacheUtilities.ReportsCache);
string captionColumnName = Terrasoft.Configuration.CommonUtilities.GetLczColumnName(UserConnection, "SysModuleReport", "Caption");
var reportSchemaManager = UserConnection.GetReportSchemaManager();
var pageSchemaManager = UserConnection.GetSchemaManager("PageSchemaManager") as Terrasoft.UI.WebControls.PageSchemaManager;
reportsCollection.Sort(delegate(Dictionary <string, object> p1, Dictionary <string, object> p2) {
return(p1[captionColumnName].ToString().CompareTo(p2[captionColumnName].ToString()));
});
foreach (var report in reportsCollection)
{
Guid sysModuleId = new Guid(report["sysModuleId"].ToString());
if (SysModuleId == sysModuleId)
{
Guid reportId = new Guid(report["sysModuleReportId"].ToString());
Guid typeId = new Guid(report["typeId"].ToString());
string caption = report[captionColumnName].ToString();
string helpContextId = report["helpContextId"].ToString();
if (typeId == new Guid("32F72C9C-72C7-44E0-8C84-34C9ED17CA50"))
{
Guid reportSchemaUId = new Guid(report["sysReportSchemaUId"].ToString());
Guid sysOptionsPageSchemaUId = report["sysOptionsPageSchemaUId"] == DBNull.Value ? Guid.Empty : new Guid(report["sysOptionsPageSchemaUId"].ToString());
if (reportSchemaManager.FindItemByUId(reportSchemaUId) != null &&
(sysOptionsPageSchemaUId == Guid.Empty || pageSchemaManager.FindItemByUId(sysOptionsPageSchemaUId) != null))
{
menu.Add(CreateMenuItem(caption, reportSchemaUId.ToString()
+ @"&" + sysOptionsPageSchemaUId.ToString() + @"&" + helpContextId,
"PrintReportMenuItem_" + reportId.ToString("n"), true));
}
}
else if (typeId == new Guid("8BC259EF-4276-4906-B7A6-23DC59BE7FE2"))
{
menu.Add(CreateMenuItem(caption, reportId.ToString("n"),
"PrintReportMenuItem_" + reportId.ToString("n"), false));
}
}
}
}
}
/// <summary>
/// Gets the campaign schema.
/// </summary>
/// <param name="campaignId">The campaign identifier.</param>
/// <returns>Instance of the campaign schema.</returns>
/// <exception cref="Exception">Will be thrown in case of campaign schema absence.</exception>
public virtual CoreCampaignSchema GetCampaignSchema(Guid campaignId)
{
var select = new Select(_userConnection)
.Column("CampaignSchemaUId")
.From("Campaign")
.Where("Id")
.IsEqual(Column.Parameter(campaignId)) as Select;
var schemaUid = select.ExecuteScalar <Guid>();
if (schemaUid.IsEmpty())
{
string message = GetLczStringValue(CampaignHelperClassName, CampaignSchemaNotFoundException);
throw new Exception(message);
}
var schemaManager =
(CampaignSchemaManager)_userConnection.GetSchemaManager("CampaignSchemaManager");
return(schemaManager.FindInstanceByUId(schemaUid));
}
/// <summary>
/// Processes job for campaign action.
/// <param name="userConnection">The user connection.</param>
/// <param name="parameters">Job parameters.</param>
/// </summary>
public void Execute(UserConnection userConnection, IDictionary <string, object> parameters)
{
try {
_userConnection = userConnection;
var schemaUid = GetTypedParameter <Guid>("CampaignSchemaUId", parameters);
var scheduledFireTime = GetTypedParameter <DateTime>("ScheduledUtcFireTime", parameters);
var action = (CampaignScheduledAction)GetTypedParameter <int>("ScheduledAction", parameters);
var schemaGeneratorStrategy =
GetTypedParameter <CampaignSchemaExecutionStrategy>("SchemaGeneratorStrategy", parameters);
var schemaManager =
(CampaignSchemaManager)_userConnection.GetSchemaManager("CampaignSchemaManager");
CoreCampaignSchema campaignSchema = schemaManager.GetSchemaInstance(schemaUid);
switch (action)
{
case CampaignScheduledAction.ScheduledStart:
StartCampaign(campaignSchema, scheduledFireTime);
break;
case CampaignScheduledAction.Start:
RunCampaign(campaignSchema, schemaGeneratorStrategy, scheduledFireTime);
break;
case CampaignScheduledAction.Run:
RunCampaignWithInProgress(campaignSchema, schemaGeneratorStrategy, scheduledFireTime);
break;
case CampaignScheduledAction.Stop:
CampaignEventFacade.Stop(_userConnection, campaignSchema);
break;
case CampaignScheduledAction.ScheduledStop:
StopCampaignByScheduledDate(campaignSchema);
break;
default:
break;
}
} catch (Exception ex) {
string message = CampaignHelper.GetLczStringValue(nameof(CampaignJobExecutor), "ExecutionException");
Logger.Error(message, ex);
throw;
}
}
public static decimal GetCurrencyRate(Guid currencyId, UserConnection userConnection)
{
var rateSelect = new Select(userConnection).Top(1)
.Column("StartDate")
.Column("Currency", "Division").As("Division")
.Column("Rate").As("Rate")
.From("CurrencyRate")
.Join(JoinType.Inner, "Currency")
.On("Currency", "Id").IsEqual(Column.Parameter(currencyId))
.Where("StartDate").IsLessOrEqual(Column.Parameter(DateTime.Today))
.And("CurrencyId").IsEqual(Column.Parameter(currencyId))
.OrderByDesc("StartDate") as Select;
var entitySchemaManager = userConnection.GetSchemaManager("EntitySchemaManager") as EntitySchemaManager;
Terrasoft.Core.Entities.EntitySchema wSchema = new Terrasoft.Core.Entities.EntitySchema(entitySchemaManager);
EntityCollection coll = new EntityCollection(userConnection, wSchema);
using (DBExecutor dbExecutor = userConnection.EnsureDBConnection()) {
using (IDataReader dataReader = rateSelect.ExecuteReader(dbExecutor)) {
coll.Load(dataReader);
}
}
if (coll.Count > 0)
{
var currencyDivision = coll[0].GetTypedColumnValue <Int32>("Division");
var currencyRate = coll[0].GetTypedColumnValue <Decimal>("Rate");
if (currencyDivision == 0)
{
currencyDivision = 1;
}
var rate = Math.Round(currencyRate / currencyDivision, 2);
return(rate);
}
else
{
return(1);
}
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
// TODO: Generate exception if OpenerPage parameter is null
/*
* Terrasoft.UI.WebControls.PageSchemaUserControl page = null;
* if (OpenerPage != null) {
* //return false;
* page = (Terrasoft.UI.WebControls.PageSchemaUserControl)OpenerPage;
* }
*/
//var page = (Terrasoft.UI.WebControls.PageSchemaUserControl)OpenerPage;
// TODO: Generate exception if PageUId and PageUrl parameters are (null or empty) and at same time
if (PageUId.IsEmpty() && string.IsNullOrEmpty(PageUrl))
{
return(false);
}
var sb = new StringBuilder();
/*
* if (UseOpenerRegisterScript) {
* sb.Append("var currentOpener = window.opener != null ? window.opener : window;\r\n");
* sb.Append("currentOpener.");
* }
*/
sb.Append("Terrasoft.openWindow(");
var sbCallback = new StringBuilder();
var sbConfig = new StringBuilder();
var nullString = "null";
var callbackString = "function(wnd) {{ {0} }}";
var window = "wnd";
// windowUrl:
if (!PageUId.IsEmpty())
{
sb.Append("'");
sb.Append("ViewPage.aspx");
sb.Append("'");
// id:
sb.Append(", ");
sb.Append("'");
sb.Append(PageUId.ToString());
sb.Append("'");
}
else
{
sb.Append("'");
sb.Append(PageUrl);
sb.Append("'");
// id:
sb.Append(", ");
sb.Append(nullString);
}
sb.Append(", ");
// params:
sb.Append("[");
bool isFirst = true;
if (PageParameters != null)
{
foreach (var parameter in (Dictionary <string, string>)PageParameters)
{
if (isFirst)
{
isFirst = false;
}
else
{
sb.Append(", ");
}
sb.Append("\n\t{name: ");
sb.Append("'");
sb.Append(parameter.Key);
sb.Append("'");
sb.Append(",");
sb.Append(" value: ");
sb.Append("'");
sb.Append(parameter.Value);
sb.Append("'");
sb.Append("}");
}
}
sb.Append("\t]");
sb.Append(", ");
var pageSchemaManager = UserConnection.GetSchemaManager("PageSchemaManager") as PageSchemaManager;
if (!PageUId.IsEmpty())
{
var pageSchema = pageSchemaManager.GetInstanceByUId(PageUId);
if (!pageSchema.Maximized)
{
// width:
sb.Append(pageSchema.Width.ToString(CultureInfo.InvariantCulture));
sb.Append(", ");
// height:
sb.Append(pageSchema.Height.ToString(CultureInfo.InvariantCulture));
sb.Append(", ");
}
else
{
// width:
sb.Append(nullString);
sb.Append(", ");
// height:
sb.Append(nullString);
sb.Append(", ");
}
}
else
{
// width:
if (Width > 0)
{
sb.Append(Width.ToString(CultureInfo.InvariantCulture));
}
else
{
sb.Append(nullString);
}
sb.Append(", ");
// height:
if (Height > 0)
{
sb.Append(Height.ToString(CultureInfo.InvariantCulture));
}
else
{
sb.Append(nullString);
}
sb.Append(", ");
}
// isCenterWindow:
var centered = Centered as bool?;
if (!centered.HasValue)
{
sb.Append("true");
}
else
{
if (centered.Value)
{
sb.Append("true");
}
else
{
sb.Append("false");
}
}
sb.Append(", ");
// isToolBarVisible:
sb.Append(nullString);
sb.Append(", ");
// openInExistingWindow:
sb.Append(nullString);
// key setting:
sbCallback.Append("\nvar windowKey = ");
// sbCallback.Append(window);
// sbCallback.Append(".key = ");
sbCallback.Append("'");
if (!string.IsNullOrEmpty(OpenerInstanceId))
{
sbCallback.Append(OpenerInstanceId);
}
else
{
/*
* if (page != null) {
* sbCallback.Append(((Terrasoft.UI.WebControls.Page)page.AspPage).InstanceId.ToString());
* sbCallback.Append(page.PageContainer.UniqueID);
* }*/
}
sbCallback.Append("'");
sbCallback.Append(";");
sbCallback.Append("\nwnd.key = windowKey;");
// opener closing:
if (CloseOpenerOnLoad)
{
sbCallback.Append("\nif (window.mainPage != window) {");
sbCallback.Append("\n\tExt.lib.Event.on(");
sbCallback.Append(window);
sbCallback.Append(", 'load', function() {\n\t\twindow.close()\n});");
sbCallback.Append("\n}");
}
// close message:
if (!string.IsNullOrEmpty(CloseMessage))
{
sbCallback.Append(@"
var pickHoleInRegisterListener = function(attemptsCount) {
setTimeout(function() {
try {
attemptsCount--;
Ext.EventManager.on(wnd, 'beforeunload', function() {
if (Terrasoft.AjaxMethods.ThrowClientEvent) {
var wndKey = windowKey;
setTimeout(function() {
Terrasoft.AjaxMethods.ThrowClientEvent(wndKey,'" );
sbCallback.Append(CloseMessage);
sbCallback.Append(@"');}, 10);
}
});
} catch(e) {
if (attemptsCount === 0) {
throw e;
}
pickHoleInRegisterListener(attemptsCount);
}
}, 200);
};
pickHoleInRegisterListener(10);" );
}
sb.Append(", ");
sb.Append(string.Format(callbackString, sbCallback.ToString()));
sb.Append(", ");
// ignoreRequestId:
sb.Append(nullString);
sb.Append(", ");
// windowName
sb.Append(nullString);
sb.Append(", ");
// useApplicationPath
sb.Append(nullString);
sb.Append(", ");
// config
sbConfig.Append("\n{");
// config:ignoreProfile
sbConfig.Append(string.Format("ignoreProfile:{0}", IgnoreProfile ? "true" : "false"));
sbConfig.Append("}");
sb.Append(sbConfig);
sb.Append(");");
// script adding:
/*
* ScriptManager scriptManager = null;
* if (page == null) {
* } else {
* scriptManager = page.GetPropertyValue("ScriptManager") as ScriptManager;
* }
*/
//ScriptManager scriptManager = ((Terrasoft.UI.WebControls.Page)System.Web.HttpContext.Current.CurrentHandler).FindControl("ScriptManager") as ScriptManager;
//Hack: Asp.Net has an artificial limit on the size of the stack
ScriptManager scriptManager = Terrasoft.UI.WebControls.Page.FindControlByClientId(((System.Web.UI.Control)System.Web.HttpContext.Current.CurrentHandler), "ScriptManager", true) as ScriptManager;
string script = sb.ToString();
if (!UseCurrentActivePage)
{
script = "var executePage = window.mainPage || window; executePage.eval('" + script.Replace(@"\", @"\\").Replace(@"'", @"\'").Replace("\n", " ").Replace("\r", " ") + "');";
}
scriptManager.AddScript(script);
//OpenerPage = null;
return(true);
}
/// <summary>
/// ####### #########.
/// </summary>
/// <param name="userConnection">######### ################# ###########.</param>
public static void WarmupManager <TM, TS>(UserConnection userConnection)
where TM : ISchemaManager
where TS : Schema, ISchemaManagerSchema <TS>
{
WarmupManager <TM, TS>(userConnection.GetSchemaManager(typeof(TM).Name));
}
private static void WarmupEntities(UserConnection userConnection)
{
WarmupManager <EntitySchemaManager, EntitySchema>(userConnection
.GetSchemaManager(typeof(EntitySchemaManager).Name));
}
