public UserControl GetVisualisationUserControl(IConfigurable configuration)
{
_antWarsViewModel = new AntWarsViewModel();
_movementService = new MovementService(_antWarsViewModel);
_botService = new BotService(_antWarsViewModel);
return new AntWarsUserControl(_antWarsViewModel);
}
public EditAvailableConfigurationsDialog(IConfigurable configurable, bool editPlatforms)
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
foreach (Control ctl in this.Controls) {
ctl.Text = StringParser.Parse(ctl.Text);
}
this.configurable = configurable;
this.editPlatforms = editPlatforms;
if (editPlatforms) {
if (configurable is ISolution)
this.Text = StringParser.Parse("${res:Dialog.EditAvailableConfigurationsDialog.EditSolutionPlatforms}");
else
this.Text = StringParser.Parse("${res:Dialog.EditAvailableConfigurationsDialog.EditProjectPlatforms}");
this.editedCollection = configurable.PlatformNames;
} else {
if (configurable is ISolution)
this.Text = StringParser.Parse("${res:Dialog.EditAvailableConfigurationsDialog.EditSolutionConfigurations}");
else
this.Text = StringParser.Parse("${res:Dialog.EditAvailableConfigurationsDialog.EditProjectConfigurations}");
this.editedCollection = configurable.ConfigurationNames;
}
InitList();
}
public ConfigurationWindow(NovaromaEngine engine, IExceptionHandler exceptionHandler, IDialogService dialogService) {
InitializeComponent();
_configurableEngine = engine;
_engine = engine;
_downloader = engine.Settings.Downloader.SelectedItem as IConfigurable;
_exceptionHandler = exceptionHandler;
_dialogService = dialogService;
_initialMovieDir = engine.MovieDirectory;
_initialTvShowDir = engine.TvShowDirectory;
_engineSettings = engine.Settings;
var utor = _downloader as UTorrentDownloader;
if (utor != null && utor.IsAvailable) {
_torrentSettings = utor.Settings;
TorrentHowToHyperink.NavigateUri = new Uri(Properties.Resources.Url_HowToConfigureUtorrentWebUISettings);
}
else {
var trantor = _downloader as TransmissionDownloader;
if (trantor != null) {
_torrentSettings = trantor.Settings;
TorrentHowToHyperink.NavigateUri = new Uri(Properties.Resources.Url_HowToConfigureTransmissionWebUISettings);
}
}
if (_torrentSettings == null)
TorrentSettingsExpander.Visibility = Visibility.Collapsed;
else if (_downloader != null)
TorrentSettingsExpander.Tag = string.Format(Properties.Resources.TorrentWebUISettings, _downloader.SettingName);
DataContext = this;
Closing += OnClosing;
}
public PreprocessorComponentForm(IConfigurable iComponent)
{
if (iComponent == null) throw new ArgumentNullException();
_configuredComponent = iComponent;
InitializeComponent();
preprocessorsComboBox.Items.AddRange((_configuredComponent.GetValueForKey("preprocessorsList") as object[]));
inputsCountTextBox.Text = _configuredComponent.GetValueForKey("defaultInputsCount") as string;
}
public SettingsViewModel(INovaromaEngine engine, IDialogService dialogService, IConfigurable configurable): base(dialogService) {
_engine = engine;
_configurable = configurable;
_settings = configurable.Settings;
_initialValues = configurable.SerializeSettings();
_editServiceSettingsCommand = new RelayCommand(EditServiceSettings);
}
public BSModelBuilderComponentForm(IConfigurable iConfiguredComponent)
: base()
{
if (iConfiguredComponent == null) throw new ArgumentNullException();
_configuredComponent = iConfiguredComponent;
InitializeComponent();
modelsListComboBox.Items.AddRange((_configuredComponent.GetValueForKey("modelsList") as object[]));
inputsCountTextBox.Text = _configuredComponent.GetValueForKey("defaultInputsCount") as string;
}
public UserControl GetVisualization(IConfigurable configuration)
{
if (Bots != null)
{
_tournamentLadderViewModel = new TournamentLadderViewModel(Bots);
return new TournamentLadderControl(_tournamentLadderViewModel);
}
return null;
}
internal IEnumerable <T> GetObjects <T>(ObjectId rootId, IConfigDataProvider session, OptionalIdentityData optionalData, out LocalizedString?notFoundReason) where T : IConfigurable, new()
{
if (!(session is ContentFilterPhraseDataProvider))
{
throw new ArgumentException(Strings.ErrorInvalidType((session != null) ? session.GetType().Name : "null"), "session");
}
notFoundReason = null;
IConfigurable configurable = session.Read <T>(new ContentFilterPhraseIdentity(this.phrase));
T[] result;
if (configurable != null)
{
result = new T[]
{
(T)((object)configurable)
};
}
else
{
result = new T[0];
}
return(result);
}
public Object GetDelegate(DelegationImpl delegationImpl)
{
Object delegateClass = null;
IClassLoader classLoader = null;
try
{
classLoader = (IClassLoader)ServiceLocator.Instance.GetService(typeof(IClassLoader));
delegateClass = classLoader.CreateObject(delegationImpl);
}
finally
{
ServiceLocator.Instance.Release(classLoader);
}
// configure class
if (delegateClass is IConfigurable)
{
IConfigurable configurable = (IConfigurable)delegateClass;
IDictionary parameters = ParseConfiguration(delegationImpl);
configurable.SetConfiguration(parameters);
}
return(delegateClass);
}
private void OnNewConnection(Control control1, Point p1, Control control2, Point p2)
{
Cursor = Cursors.Default;
foreach (var c in Controls.OfType <Control>())
{
c.Cursor = Cursor;
}
IConfigurable ws1 = control1 as IConfigurable;
IConfigurable ws2 = control2 as IConfigurable;
if (ws1 == null || ws2 == null)
{
return;
}
int port1 = ws1.GetPortIDByPoint(p1);
int port2 = ws2.GetPortIDByPoint(p2);
if (port1 < 0 || port2 < 0)
{
return;
}
NewConnectionCreated?.Invoke((Control)ws1, port1, (Control)ws2, port2);
}
protected override bool ShouldSkipObject(IConfigurable dataObject)
{
if (dataObject is PagedPositionInfo)
{
return(false);
}
RecipientType recipientType;
RecipientTypeDetails recipientTypeDetails;
if (dataObject is ReducedRecipient)
{
ReducedRecipient reducedRecipient = dataObject as ReducedRecipient;
recipientType = reducedRecipient.RecipientType;
recipientTypeDetails = reducedRecipient.RecipientTypeDetails;
}
else
{
ADRecipient adrecipient = dataObject as ADRecipient;
recipientType = adrecipient.RecipientType;
recipientTypeDetails = adrecipient.RecipientTypeDetails;
}
return(Array.IndexOf <RecipientType>(this.RecipientTypes, recipientType) == -1 || (this.InternalRecipientTypeDetails != null && this.InternalRecipientTypeDetails.Length > 0 && Array.IndexOf <RecipientTypeDetails>(this.InternalRecipientTypeDetails, recipientTypeDetails) == -1));
}
public void Save(IConfigurable instance, bool keepUnmanagedResources)
{
this.DisposeCheck();
MapiObject mapiObject = instance as MapiObject;
if (mapiObject == null)
{
throw new ArgumentException("instance");
}
if (mapiObject.MapiSession == null)
{
mapiObject.MapiSession = this;
}
ValidationError[] array = mapiObject.Validate();
if (array != null && 0 < array.Length)
{
throw new DataValidationException(array[0]);
}
this.InvokeWithWrappedException(delegate()
{
mapiObject.Save(keepUnmanagedResources);
}, (instance.ObjectState == ObjectState.New) ? Strings.ExceptionNewObject((instance.Identity == null) ? Strings.ConstantNull : instance.Identity.ToString()) : Strings.ExceptionSaveObject((instance.Identity == null) ? Strings.ConstantNull : instance.Identity.ToString()), null);
}
protected override IConfigurable ConvertDataObjectToPresentationObject(IConfigurable dataObject)
{
if (dataObject == null)
{
return(null);
}
ADContact dataObject2 = (ADContact)dataObject;
SyncMailContact syncMailContact = new SyncMailContact(dataObject2);
syncMailContact.propertyBag.SetField(ADRecipientSchema.AcceptMessagesOnlyFrom, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailContact.AcceptMessagesOnlyFrom));
syncMailContact.propertyBag.SetField(ADRecipientSchema.AcceptMessagesOnlyFromDLMembers, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailContact.AcceptMessagesOnlyFromDLMembers));
syncMailContact.propertyBag.SetField(ADRecipientSchema.RejectMessagesFrom, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailContact.RejectMessagesFrom));
syncMailContact.propertyBag.SetField(ADRecipientSchema.RejectMessagesFromDLMembers, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailContact.RejectMessagesFromDLMembers));
if (this.outputCookie != null)
{
syncMailContact.propertyBag.SetField(SyncMailContactSchema.Cookie, this.outputCookie.ToBytes());
if (this.outputCookie.HighWatermark == 0L)
{
syncMailContact.propertyBag.SetField(SyncMailContactSchema.EndOfList, true);
}
}
return(syncMailContact);
}
protected override void WriteResult(IConfigurable dataObject)
{
TaskLogger.LogEnter(new object[]
{
dataObject.Identity
});
TenantRelocationRequest tenantRelocationRequest = (TenantRelocationRequest)dataObject;
if (!this.SourceStateOnly)
{
if (tenantRelocationRequest.TargetForest != null)
{
this.targetForestRIDMaster = ForestTenantRelocationsCache.GetRidMasterName(new PartitionId(tenantRelocationRequest.TargetForest));
}
Exception ex;
TenantRelocationRequest.PopulatePresentationObject(tenantRelocationRequest, this.targetForestRIDMaster, out ex);
if (ex != null)
{
if (ex is CannotFindTargetTenantException)
{
base.WriteWarning(ex.Message);
}
else
{
base.WriteError(ex, ErrorCategory.InvalidOperation, tenantRelocationRequest.Identity);
}
}
GetTenantRelocationRequest.PopulateGlsProperty(tenantRelocationRequest, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose));
GetTenantRelocationRequest.PopulateRidMasterProperties(tenantRelocationRequest, this.sourceForestRIDMaster, this.targetForestRIDMaster, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose));
if (tenantRelocationRequest.OriginatingServer != this.sourceForestRIDMaster)
{
this.warning = Strings.WarningShouldReadFromRidMaster(tenantRelocationRequest.OriginatingServer, this.sourceForestRIDMaster);
}
}
base.WriteResult(tenantRelocationRequest);
TaskLogger.LogExit();
}
public override void Save(IConfigurable instance)
{
AdminAuditLogSearch adminAuditLogSearch = (AdminAuditLogSearch)instance;
AdminAuditLogSearch adminAuditLogSearch2 = new AdminAuditLogSearch();
adminAuditLogSearch2.Identity = (AuditLogSearchId)adminAuditLogSearch.Identity;
adminAuditLogSearch2.Name = adminAuditLogSearch.Name;
adminAuditLogSearch2.StartDateUtc = new DateTime?(adminAuditLogSearch.StartDateUtc.Value);
adminAuditLogSearch2.EndDateUtc = new DateTime?(adminAuditLogSearch.EndDateUtc.Value);
adminAuditLogSearch2.StatusMailRecipients = NewAuditLogSearchBase <AdminAuditLogSearch> .GetMultiValuedSmptAddressAsStrings(adminAuditLogSearch.StatusMailRecipients);
adminAuditLogSearch2.CreatedBy = adminAuditLogSearch.CreatedBy;
adminAuditLogSearch2.CreatedByEx = adminAuditLogSearch.CreatedByEx;
adminAuditLogSearch2.Cmdlets = adminAuditLogSearch.Cmdlets;
adminAuditLogSearch2.Parameters = adminAuditLogSearch.Parameters;
adminAuditLogSearch2.ObjectIds = adminAuditLogSearch.ObjectIds;
if (adminAuditLogSearch.ExternalAccess != null)
{
adminAuditLogSearch2.ExternalAccess = (adminAuditLogSearch.ExternalAccess.Value ? bool.TrueString : bool.FalseString);
}
adminAuditLogSearch2.UserIds = adminAuditLogSearch.UserIds;
adminAuditLogSearch2.ResolvedUsers = adminAuditLogSearch.ResolvedUsers;
adminAuditLogSearch2.RedactDatacenterAdmins = adminAuditLogSearch.RedactDatacenterAdmins;
base.Save(adminAuditLogSearch2);
AuditQueuesOpticsLogData auditQueuesOpticsLogData = new AuditQueuesOpticsLogData
{
QueueType = AuditQueueType.AsyncAdminSearch,
EventType = QueueEventType.Queue,
CorrelationId = adminAuditLogSearch2.Identity.Guid.ToString(),
OrganizationId = this.organizationId,
QueueLength = ((this.defaultFolder != null) ? (this.defaultFolder.TotalCount + 1) : 1)
};
auditQueuesOpticsLogData.Log();
instance.ResetChangeTracking();
}
private static void SaveConfig(Type type, IConfigurable configurable)
{
var configPath = $"Config\\{type.Name}.xml";
Log.Config.Trace($"Saving config file: {configPath}");
try
{
// Serialize config
var document = new XDocument();
{
var rootElement = new XElement(type.Name);
configurable.Serialize(rootElement);
document.Add(rootElement);
}
document.Save(configPath);
}
catch (Exception e)
{
Log.Config.Error($"Failed to save config file: {configPath}");
Log.Config.Trace(e.Message);
}
}
private static void LoadConfig(Type type, IConfigurable configurable)
{
// Deserialize config
var configPath = $"Config\\{type.Name}.xml";
if (File.Exists(configPath))
{
Log.Config.Trace($"Loading config file: {configPath}");
try
{
var document = XDocument.Load(configPath);
if (document.Root != null)
{
configurable.Deserialize(document.Root);
}
}
catch (Exception e)
{
Log.Config.Error($"Failed to load config file: {configPath}");
Log.Config.Trace(e.Message);
}
}
}
protected override void StampChangesOn(IConfigurable dataObject)
{
TaskLogger.LogEnter();
PimSubscriptionProxy pimSubscriptionProxy = (PimSubscriptionProxy)dataObject;
if (base.Fields.IsModified("DisplayName"))
{
pimSubscriptionProxy.DisplayName = this.DisplayName;
}
SubscriptionStateTransitionHelper subscriptionStateTransitionHelper = new SubscriptionStateTransitionHelper(pimSubscriptionProxy.Subscription);
if (this.DisableAsPoison)
{
subscriptionStateTransitionHelper.DisableAsPoisonous();
}
else if (this.EnablePoisonSubscription)
{
if (this.Enabled)
{
subscriptionStateTransitionHelper.EnableFromPoison();
}
else
{
subscriptionStateTransitionHelper.Disable();
}
}
else if (this.Enabled)
{
subscriptionStateTransitionHelper.Enable();
}
else
{
subscriptionStateTransitionHelper.Disable();
}
TaskLogger.LogExit();
}
internal static MultiValuedProperty <ADObjectId> ValidateVirtualDirectory(IConfigDataProvider session, VirtualDirectoryIdParameter[] virtualDirectories, OfflineAddressBookTaskUtility.GetUniqueObject getOabVirtualDirectory, OfflineAddressBook target, Task.TaskErrorLoggingDelegate writeError)
{
MultiValuedProperty <ADObjectId> multiValuedProperty = new MultiValuedProperty <ADObjectId>(false, OfflineAddressBookSchema.VirtualDirectories, new object[0]);
foreach (VirtualDirectoryIdParameter virtualDirectoryIdParameter in virtualDirectories)
{
if (virtualDirectoryIdParameter != null)
{
IConfigurable configurable = getOabVirtualDirectory(virtualDirectoryIdParameter, session, null, new LocalizedString?(Strings.OabVirtualDirectoryNotExisting(virtualDirectoryIdParameter.ToString())), new LocalizedString?(Strings.OabVirtualDirectoryAmbiguous(virtualDirectoryIdParameter.ToString())));
if (configurable != null)
{
if (multiValuedProperty.Contains((ADObjectId)configurable.Identity))
{
writeError(new InvalidOperationException(Strings.ErrorOabVDirAlreadyAssigned((target.Identity != null) ? target.Identity.ToString() : target.Name, configurable.Identity.ToString())), ErrorCategory.InvalidOperation, target.Identity);
}
else
{
multiValuedProperty.Add((ADObjectId)configurable.Identity);
}
}
}
}
return(multiValuedProperty);
}
protected override void WriteResult()
{
TaskLogger.LogEnter(new object[]
{
this.DataObject.Identity
});
base.WriteVerbose(TaskVerboseStringHelper.GetReadObjectVerboseString(this.DataObject.Identity, base.DataSession, typeof(TransactionalRequestJob)));
IConfigurable configurable = null;
try
{
try
{
configurable = base.DataSession.Read <TransactionalRequestJob>(this.DataObject.Identity);
}
finally
{
base.WriteVerbose(TaskVerboseStringHelper.GetSourceVerboseString(base.DataSession));
}
if (configurable == null)
{
base.WriteError(new ManagementObjectNotFoundException(base.GetErrorMessageObjectNotFound(this.DataObject.Identity.ToString(), typeof(TRequest).ToString(), (base.DataSession != null) ? base.DataSession.Source : null)), (ErrorCategory)1003, this.DataObject.Identity);
}
this.WriteResult(configurable);
}
finally
{
IDisposable disposable = configurable as IDisposable;
if (disposable != null)
{
disposable.Dispose();
configurable = null;
}
}
TaskLogger.LogExit();
}
protected IConfigurable GetDataObject <TObject>(IIdentityParameter id, IConfigDataProvider session, ObjectId rootID, OptionalIdentityData optionalData, LocalizedString notFoundError, LocalizedString multipleFoundError) where TObject : IConfigurable, new()
{
IConfigurable result = null;
LocalizedString? localizedString = null;
IEnumerable <TObject> objects = id.GetObjects <TObject>(rootID, session, optionalData, out localizedString);
using (IEnumerator <TObject> enumerator = objects.GetEnumerator())
{
if (enumerator.MoveNext())
{
result = enumerator.Current;
if (enumerator.MoveNext())
{
Exception innerException = new ManagementObjectAmbiguousException(multipleFoundError);
base.WriteError(new TaskInvalidOperationException(multipleFoundError, innerException), ExchangeErrorCategory.Client, this.Identity);
}
}
else
{
LocalizedString message;
if (localizedString != null)
{
string notFound = notFoundError;
LocalizedString?localizedString2 = localizedString;
message = Strings.ErrorNotFoundWithReason(notFound, (localizedString2 != null) ? localizedString2.GetValueOrDefault() : null);
}
else
{
message = notFoundError;
}
Exception innerException = new ManagementObjectNotFoundException(message);
base.WriteError(new TaskInvalidOperationException(notFoundError, innerException), ExchangeErrorCategory.Client, this.Identity);
}
}
return(result);
}
protected override void WriteResult(IConfigurable dataObject)
{
ReceiveConnector receiveConnector = dataObject as ReceiveConnector;
if (receiveConnector != null && !receiveConnector.IsReadOnly)
{
Server permissionGroupsBasedOnSecurityDescriptor = (Server)base.GetDataObject <Server>(new ServerIdParameter(receiveConnector.Server), base.DataSession, this.RootId, new LocalizedString?(Strings.ErrorServerNotFound(receiveConnector.Server.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(receiveConnector.Server.ToString())));
if (base.HasErrors)
{
return;
}
try
{
receiveConnector.SetPermissionGroupsBasedOnSecurityDescriptor(permissionGroupsBasedOnSecurityDescriptor);
}
catch (LocalizedException exception)
{
base.WriteError(exception, ErrorCategory.InvalidOperation, dataObject);
return;
}
receiveConnector.ResetChangeTracking();
}
base.WriteResult(dataObject);
}
/// <summary>
/// Get information about an object.
/// </summary>
/// <param name="forInstance"></param>
/// <param name="instance"></param>
/// <param name="description"></param>
/// <returns></returns>
private bool GetObjectInformation(Guid forInstance, out IUserObject instance, out IConfigurationDescription description)
{
description = null;
instance = GetInstance(forInstance);
if (instance == null)
{
this.Log().Warn("Requested configuration for non-existant object '{0}'", forInstance);
return(false);
}
IConfigurable configurable = instance as IConfigurable;
if (configurable == null)
{
this.Log().Warn("Requested configuration for unconfigurable object '{0}' (Class {1}.{2})", forInstance, instance.GetType().Namespace, instance.GetType().Name);
return(false);
}
description = GetConfigurationDescription(forInstance);
if (description == null)
{
this.Log().Warn("No configuration description for object '{0}' (Class {1}.{2})", forInstance, instance.GetType().Namespace, instance.GetType().Name);
return(false);
}
return(true);
}
protected override void WriteResult(IConfigurable dataObject)
{
TaskLogger.LogEnter();
ADUser aduser = (ADUser)dataObject;
ADObjectId owaMailboxPolicy;
if (aduser.OwaMailboxPolicy != null && OwaSegmentationSettings.UpdateOwaMailboxPolicy(aduser.OrganizationId, aduser.OwaMailboxPolicy, out owaMailboxPolicy))
{
aduser.OwaMailboxPolicy = owaMailboxPolicy;
}
if (this.RecalculateHasActiveSyncDevicePartnership == true)
{
IConfigurationSession configurationSession = this.GetConfigurationSession();
MobileDevice[] array = configurationSession.Find <MobileDevice>(aduser.ObjectId, QueryScope.SubTree, null, null, 0);
bool flag = array.Length > 0;
if (flag != aduser.HasActiveSyncDevicePartnership)
{
aduser.HasActiveSyncDevicePartnership = flag;
IRecipientSession recipientSession = (IRecipientSession)this.CreateSession();
recipientSession.Save(aduser);
}
}
base.WriteResult(aduser);
}
public void Save(IConfigurable instance)
{
PimSubscriptionProxy pimSubscriptionProxy = instance as PimSubscriptionProxy;
switch (pimSubscriptionProxy.ObjectState)
{
case ObjectState.New:
this.NewAggregationSubscription(pimSubscriptionProxy);
return;
case ObjectState.Unchanged:
return;
case ObjectState.Changed:
this.UpdateAggregationSubscription(pimSubscriptionProxy);
return;
case ObjectState.Deleted:
throw new InvalidOperationException("Calling Save() on a deleted object is not permitted. Delete() should be used instead.");
default:
return;
}
}
protected override void WriteResult(IConfigurable dataObject)
{
TaskLogger.LogEnter(new object[]
{
dataObject.Identity,
dataObject
});
MailboxServer mailboxServer = new MailboxServer((Server)dataObject);
string fqdn = ((Server)dataObject).Fqdn;
if (this.Status && ((Server)dataObject).IsProvisionedServer)
{
this.WriteWarning(Strings.StatusSpecifiedForProvisionedServer);
}
if (this.Status && !mailboxServer.IsReadOnly && !((Server)dataObject).IsProvisionedServer)
{
if (string.IsNullOrEmpty(fqdn))
{
this.WriteWarning(Strings.ErrorInvalidObjectMissingCriticalProperty(typeof(Server).Name, mailboxServer.Identity.ToString(), ServerSchema.Fqdn.Name));
}
else
{
Exception ex = null;
CultureInfo[] array;
GetMailboxServer.GetConfigurationFromRegistry(fqdn, out array, out ex);
if (ex != null)
{
this.WriteWarning(Strings.ErrorAccessingRegistryRaisesException(fqdn, ex.Message));
}
mailboxServer.Locale = array;
mailboxServer.ResetChangeTracking();
}
}
base.WriteResult(mailboxServer);
TaskLogger.LogExit();
}
protected override IConfigurable ResolveDataObject()
{
if (this.Identity == null)
{
IConfigurable[] array = null;
try
{
array = base.DataSession.Find <ActiveSyncOrganizationSettings>(null, this.RootId, false, null);
}
catch (DataSourceTransientException exception)
{
base.WriteError(exception, (ErrorCategory)1002, null);
}
if (array == null)
{
array = new IConfigurable[0];
}
IConfigurable result = null;
switch (array.Length)
{
case 0:
base.WriteError(new ManagementObjectNotFoundException(base.GetErrorMessageObjectNotFound(null, typeof(ActiveSyncOrganizationSettings).ToString(), (base.DataSession != null) ? base.DataSession.Source : null)), (ErrorCategory)1003, null);
break;
case 1:
result = array[0];
break;
default:
base.WriteError(new ManagementObjectAmbiguousException(Strings.ActiveSyncOrganizationSettingsAmbiguous), (ErrorCategory)1003, null);
break;
}
return(result);
}
return(base.ResolveDataObject());
}
protected override void StampChangesOnXsoObject(IConfigurable dataObject)
{
base.StampChangesOnXsoObject(dataObject);
MailboxMessageConfiguration mailboxMessageConfiguration = (MailboxMessageConfiguration)dataObject;
if (mailboxMessageConfiguration.IsModified(MailboxMessageConfigurationSchema.SignatureHtml))
{
mailboxMessageConfiguration.SignatureHtml = TextConverterHelper.SanitizeHtml(mailboxMessageConfiguration.SignatureHtml);
if (!mailboxMessageConfiguration.IsModified(MailboxMessageConfigurationSchema.SignatureText))
{
mailboxMessageConfiguration.SignatureText = TextConverterHelper.HtmlToText(mailboxMessageConfiguration.SignatureHtml, true);
}
}
else if (mailboxMessageConfiguration.IsModified(MailboxMessageConfigurationSchema.SignatureText))
{
mailboxMessageConfiguration.SignatureHtml = TextConverterHelper.TextToHtml(mailboxMessageConfiguration.SignatureText);
}
if (SyncUtilities.IsDatacenterMode() && mailboxMessageConfiguration.IsModified(MailboxMessageConfigurationSchema.SendAddressDefault))
{
SendAsDefaultsManager sendAsDefaultsManager = new SendAsDefaultsManager();
sendAsDefaultsManager.SaveSettingForOutlook(mailboxMessageConfiguration.SendAddressDefault, this.mailboxSession);
}
this.mailboxSession = null;
}
protected override void WriteResult(IConfigurable dataObject)
{
InterceptorRule interceptorRule = dataObject as InterceptorRule;
InterceptorAgentRule interceptorAgentRule = null;
try
{
interceptorAgentRule = InterceptorAgentRule.CreateRuleFromXml(interceptorRule.Xml);
}
catch (InvalidOperationException exception)
{
base.WriteError(exception, ErrorCategory.InvalidOperation, this.Identity);
TaskLogger.LogExit();
return;
}
catch (FormatException exception2)
{
base.WriteError(exception2, ErrorCategory.InvalidOperation, this.Identity);
TaskLogger.LogExit();
return;
}
interceptorAgentRule.SetPropertiesFromAdObjet(interceptorRule);
base.WriteResult(interceptorAgentRule);
}
/// <summary>
/// Initializes a new instance of the <see cref="FileWatchHandler" /> class.
/// </summary>
/// <param name="repository">The repository to configure.</param>
/// <param name="configFile">The configuration file to watch.</param>
/// <remarks>
/// <para>
/// Initializes a new instance of the <see cref="FileWatchHandler" /> class.
/// </para>
/// </remarks>
public FileWatchHandler(IConfigurable repository, FileInfo configFile)
{
_repository = repository;
_configFileInfo = configFile;
}
internal PluginConfiuration(string name, IConfigurable config)
{
this.name = name;
this.config = config;
ForceLoad();
}
/// <summary> /// Gets the <see cref="MemoryAllocator"/> assigned to 'source'. /// </summary> /// <param name="source">The source image.</param> /// <returns>Returns the configuration.</returns> internal static MemoryAllocator GetMemoryAllocator(this IConfigurable source) => GetConfiguration(source).MemoryAllocator;
private void HandleObject(IPAddress senderIPAddress, IConfigurable theObject)
{
if (theObject is GameMessage)
{
lock (ChatLock)
{
var gameMessage = (GameMessage)theObject;
ChatText.AppendLine(gameMessage.Content);
if (IsHost)
{
_host.SendObjectTCP(gameMessage);
}
}
NewChatMessage = true;
return;
}
if (theObject is PlayerList)
{
lock (PlayerListLock)
{
PlayerList = (PlayerList)theObject;
}
NewPlayerListUpdate = true;
return;
}
if (theObject is NetworkMessage)
{
ReceiveNetworkMessage(senderIPAddress, (NetworkMessage)theObject);
return;
}
if (theObject is Player)
{
var thePlayer = (Player)theObject;
string name = thePlayer.Name;
foreach (var item in _clientAddressesAndMonikers)
{
if (item.Value[NAME].Equals(name))
{
PlayerManager.Players[(int)item.Value[ID]] = thePlayer;
thePlayer.ShipSprite = SpriteManager.GetShipSprite(thePlayer.ShipSize, thePlayer.ShipStyle, Random);
return;
}
}
return;
}
if (theObject is Ship)
{
Ship ship = (Ship)theObject;
int ownerID = (int)_clientAddressesAndMonikers[senderIPAddress][ID];
Player player = PlayerManager.Players[ownerID];
player.ClientIsDead = ship.IsDead;
player.IsDead = ship.IsDead;
player.Energy = ship.Energy;
player.PositionX = ship.PositionX;
player.PositionY = ship.PositionY;
player.VelocityX = ship.VelocityX;
player.VelocityY = ship.VelocityY;
player.Angle = ship.Angle;
}
if (theObject is ShipList)
{
var ships = ((ShipList)theObject).Ships;
var thePlayers = PlayerManager.Players;
while (thePlayers.Count < ships.Count)
{
thePlayers.Add(new Player(1, 1, Color.Red));
}
for (int j = 0; j < ships.Count; ++j)
{
var theShip = ships[j];
thePlayers[j].Name = theShip.OwnerName;
thePlayers[j].IsDead = theShip.IsDead;
thePlayers[j].ClientIsDead = theShip.IsDead;
}
return;
}
if (theObject is AsteroidsList)
{
AsteroidManager.Asteroids = ((AsteroidsList)theObject).Asteroids;
}
if (theObject is CombatData)
{
var combatData = (CombatData)theObject;
for (int i = 0; i < combatData.ShipList.Ships.Count; i++)
{
if (i != MainPlayerID || combatData.OverrideClient)
{
var player = PlayerManager.Players[i];
var ship = combatData.ShipList.Ships[i];
player.IsDead = ship.IsDead;
player.Energy = ship.Energy;
player.ClientIsDead = ship.IsDead;
player.PositionX = ship.PositionX;
player.PositionY = ship.PositionY;
player.VelocityX = ship.VelocityX;
player.VelocityY = ship.VelocityY;
player.Angle = ship.Angle;
}
}
ObjectManager.Bullets = combatData.Bullets;
ObjectManager.Shockwaves = combatData.Shockwaves;
LevelSize = combatData.LevelSize;
return;
}
if (theObject is PlayerFired)
{
if (_host == null) //Clients don't care about this
{
return;
}
var playerFired = (PlayerFired)theObject;
var player = PlayerManager.Players[playerFired.PlayerID];
//Make sure to update player to correct position and angle
player.Angle = playerFired.Angle;
player.PositionX = playerFired.PositionX;
player.PositionY = playerFired.PositionY;
player.VelocityX = playerFired.VelocityX;
player.VelocityY = playerFired.VelocityY;
player.Energy = playerFired.Energy;
ObjectManager.AddBullet(player);
return;
}
}
public UserControl GetVisualization(IConfigurable configuration)
{
_viewModel = new RoundRobinViewModel(Bots);
return new RoundRobinUserControl(_viewModel);
}
public UserControl GetVisualisationUserControl(IConfigurable configuration)
{
_configuration = configuration;
TicTacToeViewModel = new TicTacToeViewModel();
return new TicTacToeUserControl(TicTacToeViewModel);
}
private void SendObjectTcpToClient(IConfigurable obj, TcpClient client)
{
NetworkStream stream = client.GetStream();
string data = _objectStringConverter.ObjectToString(obj);
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(data);
stream.BeginWrite(bytes, 0, bytes.Length, OnTcpDataSent, client);
}
public ConfigNode BuildChildForHost(IConfigurable host)
{
ConfigNode cn = new ConfigNode(this);
cn.AttatchToHost(host);
return cn;
}
public ConfigNode BuildSiblingForHost(IConfigurable host)
{
ConfigNode cn = new ConfigNode(_parentNode);
cn.AttatchToHost(host);
return cn;
}
internal static void EditSettings(INovaromaEngine engine, IDialogService dialogService, IConfigurable configurable, Window ownerWindow = null) {
var settingsViewModel = new SettingsViewModel(engine, dialogService, configurable);
var settingsWindow = new SettingsWindow(settingsViewModel);
settingsWindow.Owner = ownerWindow;
settingsWindow.ShowDialog();
}
public static bool Load(IConfigurable target, string iniFile)
{
Debug.WriteLine("Loading configuration file " + iniFile);
// Reset to default
target.ResetParameters();
try
{
// Load custom settings from INI file
using (var ini = new IniReader(iniFile, true))
{
ini.AddHandler((x) =>
{
if (target.AcceptsConfigs.Any(y => y == x.Group))
{
target.ApplyParameter(x);
}
});
ini.Parse();
}
return true;
}
catch
{
Debug.WriteLine("Failed to load configuration from " + iniFile);
}
return false;
// DONE :)
}
public BSSaveDataComponentForm(IConfigurable iComponent)
{
component = iComponent;
InitializeComponent();
}
public void LoadConfig(IConfigSetting x, IConfigurable c)
{
c.LoadConfig(x);
}
public static void AttachRootNodeToHost(IConfigurable host)
{
ConfigNode cn = new ConfigNode();
cn.AttatchToHost(host);
}
public void SendObjectTcp(IConfigurable obj, bool tryAgainOnFailure = true)
{
string data = _objectStringConverter.ObjectToString(obj);
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(data);
NetworkStream stream = _tcpClient.GetStream();
try
{
stream.BeginWrite(bytes, 0, bytes.Length, OnTcpDataSent, _tcpClient);
}
catch (IOException exception)
{
if (tryAgainOnFailure)
{
ResetTcpClient();
SendObjectTcp(obj, false);
return;
}
SocketException innerException = exception.InnerException as SocketException;
if (innerException != null && innerException.SocketErrorCode == SocketError.ConnectionReset)
{
MessageBox.Show("Your connection with the host computer appears to have been reset. " +
"An attempt was made to fix the problem, but it failed. You are currently unable to send data to the host computer"
);
}
else
{
MessageBox.Show("You were unable to send data to the host computer. Here is what .Net says about the error: " +
exception.Message
);
}
}
}
public InputComponentForm(IConfigurable iComponent)
{
if (iComponent == null) throw new ArgumentNullException();
configuredComponent = iComponent;
InitializeComponent();
}
public UserControl GetVisualisationUserControl(IConfigurable configurable)
{
_delayTime = configurable.NextMoveDelay;
return new TankBlasterUserControl(_field);
}
public PreprocessorComponentForm()
{
_configuredComponent = null;
InitializeComponent();
}
public void AttatchToHost(IConfigurable host)
{
_host = host;
_host.Rebind(this);
}
SolutionSection GenerateSolutionConfigurationSection(IConfigurable solution)
{
SolutionSection section = new SolutionSection("SolutionConfigurationPlatforms", "preSolution");
foreach (var config in solution.ConfigurationNames) {
foreach (var platform in solution.PlatformNames) {
string key = config + "|" + platform;
section.Add(key, key);
}
}
return section;
}
internal static IConfigurable ResolveDataObject(IConfigDataProvider readOnlySession, IConfigDataProvider readOnlyConfigurationSession, IConfigDataProvider globalCatalogSession, IIdentityParameter identity, DataAccessHelper.GetDataObjectDelegate getDataObjectHandler, Task.TaskVerboseLoggingDelegate logHandler)
{
IConfigurable configurable = null;
ADObjectId adobjectId = null;
ADObjectId rootID = RecipientTaskHelper.IsValidDistinguishedName(identity, out adobjectId) ? adobjectId.Parent : null;
Exception innerException = null;
if (readOnlySession != null)
{
try
{
configurable = getDataObjectHandler(identity, readOnlySession, rootID, null, null, new LocalizedString?(Strings.ErrorObjectNotUnique(identity.ToString())));
}
catch (ADTransientException ex)
{
innerException = ex;
logHandler(Strings.VerboseCannotReadObject(identity.ToString(), readOnlySession.Source, ex.Message));
}
catch (ManagementObjectNotFoundException ex2)
{
innerException = ex2;
logHandler(Strings.VerboseCannotReadObject(identity.ToString(), readOnlySession.Source, ex2.Message));
}
}
if (configurable == null && readOnlyConfigurationSession != null)
{
try
{
configurable = getDataObjectHandler(identity, readOnlyConfigurationSession, rootID, null, null, new LocalizedString?(Strings.ErrorObjectNotUnique(identity.ToString())));
}
catch (ADTransientException ex3)
{
innerException = ex3;
logHandler(Strings.VerboseCannotReadObject(identity.ToString(), readOnlyConfigurationSession.Source, ex3.Message));
}
catch (ManagementObjectNotFoundException ex4)
{
innerException = ex4;
logHandler(Strings.VerboseCannotReadObject(identity.ToString(), readOnlyConfigurationSession.Source, ex4.Message));
}
}
if (configurable == null && globalCatalogSession != null)
{
try
{
configurable = getDataObjectHandler(identity, globalCatalogSession, rootID, null, null, new LocalizedString?(Strings.ErrorObjectNotUnique(identity.ToString())));
}
catch (ADTransientException ex5)
{
innerException = ex5;
logHandler(Strings.VerboseCannotReadObject(identity.ToString(), globalCatalogSession.Source, ex5.Message));
}
catch (ManagementObjectNotFoundException ex6)
{
innerException = ex6;
logHandler(Strings.VerboseCannotReadObject(identity.ToString(), globalCatalogSession.Source, ex6.Message));
}
}
if (configurable == null)
{
throw new ManagementObjectNotFoundException(Strings.ErrorObjectNotFound(identity.ToString()), innerException);
}
return(configurable);
}
protected override void WriteResult(IConfigurable dataObject)
{
TaskLogger.LogEnter(new object[]
{
dataObject.Identity,
dataObject
});
ADOrganizationConfig adorganizationConfig = dataObject as ADOrganizationConfig;
if (adorganizationConfig != null)
{
int?num = this.RetrieveSCLJunkThreshold(adorganizationConfig.Id);
if (num != null)
{
adorganizationConfig.SCLJunkThreshold = num.Value;
}
this.FillTaskPopulatedFields(adorganizationConfig);
MultiValuedProperty <OrganizationSummaryEntry> multiValuedProperty = new MultiValuedProperty <OrganizationSummaryEntry>();
foreach (OrganizationSummaryEntry organizationSummaryEntry in adorganizationConfig.OrganizationSummary)
{
if (OrganizationSummaryEntry.IsValidKeyForCurrentRelease(organizationSummaryEntry.Key))
{
multiValuedProperty.Add(organizationSummaryEntry.Clone());
}
}
multiValuedProperty.ResetChangeTracking();
adorganizationConfig.OrganizationSummary = multiValuedProperty;
adorganizationConfig.ResetChangeTracking();
}
ADSessionSettings sessionSettings;
if (this.AccountPartition == null)
{
sessionSettings = ADSessionSettings.RescopeToSubtree(base.OrgWideSessionSettings);
}
else
{
PartitionId partitionId = RecipientTaskHelper.ResolvePartitionId(this.AccountPartition, new Task.TaskErrorLoggingDelegate(base.WriteError));
sessionSettings = ADSessionSettings.FromAccountPartitionRootOrgScopeSet(partitionId);
}
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(base.DomainController, false, ConsistencyMode.PartiallyConsistent, sessionSettings, 109, "WriteResult", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\SystemConfigurationTasks\\organization\\GetOrganization.cs");
tenantOrRootOrgRecipientSession.UseConfigNC = true;
ADMicrosoftExchangeRecipient admicrosoftExchangeRecipient = MailboxTaskHelper.FindMicrosoftExchangeRecipient(tenantOrRootOrgRecipientSession, (IConfigurationSession)base.DataSession);
if (admicrosoftExchangeRecipient == null)
{
if (adorganizationConfig.SharedConfigurationInfo == null)
{
if (!this.IsOnlyGatewayServerRoleExist())
{
this.WriteError(new InvalidOperationException(Strings.ErrorMicrosoftExchangeRecipientNotFound), ErrorCategory.ReadError, adorganizationConfig.Identity, false);
}
else
{
base.WriteVerbose(Strings.MicrosoftExchangeRecipientNotFoundOnGatewayServerRole);
}
}
}
else
{
ValidationError[] array = admicrosoftExchangeRecipient.Validate();
for (int i = 0; i < array.Length; i++)
{
this.WriteWarning(array[i].Description);
}
adorganizationConfig.MicrosoftExchangeRecipientEmailAddresses = admicrosoftExchangeRecipient.EmailAddresses;
adorganizationConfig.MicrosoftExchangeRecipientReplyRecipient = admicrosoftExchangeRecipient.ForwardingAddress;
adorganizationConfig.MicrosoftExchangeRecipientEmailAddressPolicyEnabled = admicrosoftExchangeRecipient.EmailAddressPolicyEnabled;
adorganizationConfig.MicrosoftExchangeRecipientPrimarySmtpAddress = admicrosoftExchangeRecipient.PrimarySmtpAddress;
adorganizationConfig.ResetChangeTracking();
}
bool flag = !OrganizationId.ForestWideOrgId.Equals(adorganizationConfig.OrganizationId);
if (flag)
{
MultiValuedProperty <string> multiValuedProperty2 = this.AcceptedDomainNamesGetter(adorganizationConfig);
if (multiValuedProperty2 != null)
{
adorganizationConfig.AcceptedDomainNames = multiValuedProperty2;
}
}
if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled)
{
adorganizationConfig.HierarchicalAddressBookRoot = this.GetHierarchicalAddressBookRootFromOU(adorganizationConfig.OrganizationId.OrganizationalUnit);
}
base.WriteResult(new OrganizationConfig(adorganizationConfig, flag));
TaskLogger.LogExit();
}
public void AddItem(IConfigurable Config)
{
items.Add(new PluginConfiuration(name, Config));
}
/// <summary> /// Gets the configuration. /// </summary> /// <param name="source">The source image</param> /// <returns>Returns the bounds of the image</returns> private static Configuration GetConfiguration(IConfigurable source) => source?.Configuration ?? Configuration.Default;
public void SaveConfig(IConfigSetting x, IConfigurable c)
{
c.SaveConfig(x);
}
public PluginConfiuration(Plugin instance, IConfigurable config)
{
this.instance = instance;
this.config = config;
ForceLoad();
}
public void SendObjectTCP(IConfigurable obj)
{
string data = _objectStringConverter.ObjectToString(obj);
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(data);
var keys = _clientsAndUdpEndPoints.Keys.ToArray();
for (int j = keys.Length - 1; j >= 0; --j)
{
TcpClient tcpClient = keys[j];
NetworkStream stream = tcpClient.GetStream();
try
{
stream.BeginWrite(bytes, 0, bytes.Length, OnTcpDataSent, tcpClient);
}
/* If we can't write to this stream something is seriously wrong.
* I don't think we can redeem this client, so let's shut it down.
* When the client discovers that its connection is gone it will try
* to make a new one. If the new connection succeeds everything should
* be fine.
*/
catch
{
tcpClient.Close();
lock (_clientsAndBytes)
{
_clientsAndBytes.Remove(tcpClient);
}
if (_clientsAndUdpEndPoints.ContainsKey(tcpClient))
{
_clientsAndUdpEndPoints.Remove(tcpClient);
}
}
}
}
public PluginConfiuration(Plugin instance, IConfigurable config) : this(instance.Name, config)
{
this.instance = instance;
}
public void SendObjectTcpToClient(IConfigurable obj, IPAddress clientAddress)
{
TcpClient client = null;
foreach (var item in _clientsAndUdpEndPoints)
{
if (item.Value.Address.Equals(clientAddress))
{
client = item.Key;
SendObjectTcpToClient(obj, client);
return;
}
}
}
public void SendObjectUDP(IConfigurable obj)
{
string data = _objectStringConverter.ObjectToString(obj);
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(data);
foreach (var kvp in _clientsAndUdpEndPoints)
{
_udpClient.BeginSend(bytes, bytes.Length, kvp.Value, OnUdpDataSent, _udpClient);
}
}
void ConfigureTarget(IConfigurable target)
{
target.Configure(config);
}
