public IDataItem Transform(IDataItem dataItem)
{
foreach (var transformation in transformations)
dataItem = transformation.Transform(dataItem);
return dataItem;
}
/// <inheritdoc />
public object GetValue(IDataItem item)
{
if (item == null)
throw new ArgumentNullException("item");
return GetValueImpl(item);
}
/// <inheritdoc />
public IEnumerable<IList<IDataItem>> Join(IList<IDataProvider> providers, IList<ICollection<DataBinding>> bindingsPerProvider,
bool includeDynamicItems)
{
var enumerators = new IEnumerator<IDataItem>[providers.Count];
for (int i = 0; i < providers.Count; i++)
enumerators[i] = providers[i].GetItems(bindingsPerProvider[i], includeDynamicItems).GetEnumerator();
int providerCount = providers.Count;
for (;;)
{
var itemList = new IDataItem[providerCount];
bool gotOne = false;
for (int i = 0; i < providerCount; i++)
{
if (enumerators[i].MoveNext())
{
itemList[i] = enumerators[i].Current;
gotOne = true;
}
else
{
itemList[i] = NullDataItem.Instance;
}
}
if (! gotOne)
break;
yield return itemList;
}
}
public RemappedFieldsDataItem(IDataItem dataItem, IReadOnlyMap<string, string> fieldsMapping)
: base(dataItem)
{
Guard.NotNull("fieldsMapping", fieldsMapping);
this.fieldsMapping = fieldsMapping;
inactiveMappings = GetNonExistingMappingFields(fieldsMapping);
}
void FillInternal (DataRow row,IDataItem item)
{
if (item != null)
{
BaseImageItem bi = item as BaseImageItem;
if (bi != null) {
using (System.IO.MemoryStream memStream = new System.IO.MemoryStream()){
Byte[] val = row[bi.ColumnName] as Byte[];
if (val != null) {
if ((val[78] == 66) && (val[79] == 77)){
memStream.Write(val, 78, val.Length - 78);
} else {
memStream.Write(val, 0, val.Length);
}
System.Drawing.Image image = System.Drawing.Image.FromStream(memStream);
bi.Image = image;
}
}
}
else
{
var dataItem = item as BaseDataItem;
if (dataItem != null) {
dataItem.DBValue = ExtractDBValue(row,dataItem).ToString();
}
return;
}
}
}
public void HandlesDegenerateCaseWithOneProvider()
{
DataBinding[][] bindingsPerProvider = new DataBinding[][] {
new DataBinding[] { new DataBinding(0, null) },
};
IDataProvider[] providers = new IDataProvider[] {
Mocks.StrictMock<IDataProvider>()
};
IDataItem[][] itemsPerProvider = new IDataItem[][] {
new IDataItem[] {
new ScalarDataItem<int>(1, null, true),
new ScalarDataItem<int>(2, null, false)
},
};
using (Mocks.Record())
{
SetupResult.For(providers[0].GetItems(bindingsPerProvider[0], true)).Return(itemsPerProvider[0]);
}
using (Mocks.Playback())
{
List<IList<IDataItem>> items = new List<IList<IDataItem>>(PairwiseJoinStrategy.Instance.Join(providers, bindingsPerProvider, true));
Assert.Count(2, items);
Assert.AreSame(itemsPerProvider[0][0], items[0][0]);
Assert.AreSame(itemsPerProvider[0][1], items[1][0]);
}
}
/// <summary>
/// Deletes the check-in notification when the DataITem is deleted
/// </summary>
/// <param name="dataItem">Used only for logging in this sample, but could be used to identify which notifications to cancel
/// (in this case there is at most 1 notification)</param>
void CancelNotificationForDataItem(IDataItem dataItem)
{
if (Log.IsLoggable (Constants.TAG, LogPriority.Verbose)) {
Log.Verbose(Constants.TAG, "OnDataItemDeleted: DataItem = " + dataItem.Uri);
}
GetSystemService(NotificationService).JavaCast<NotificationManager>().Cancel(Constants.NOTIFICATION_ID);
}
public void JoinsItemsCombinatorially()
{
DataBinding[][] bindingsPerProvider = new DataBinding[][] {
new DataBinding[] { new DataBinding(0, null) },
new DataBinding[] { },
new DataBinding[] { new DataBinding(0, null) },
};
IDataProvider[] providers = new IDataProvider[] {
Mocks.StrictMock<IDataProvider>(),
Mocks.StrictMock<IDataProvider>(),
Mocks.StrictMock<IDataProvider>()
};
IDataItem[][] itemsPerProvider = new IDataItem[][] {
new IDataItem[] {
new ScalarDataItem<int>(1, null, false),
new ScalarDataItem<int>(2, null, true)
},
new IDataItem[] {
new ScalarDataItem<int>(1, null, false),
new ScalarDataItem<int>(2, null, false),
new ScalarDataItem<int>(3, null, false)
},
new IDataItem[] {
new ScalarDataItem<int>(1, null, false),
new ScalarDataItem<int>(2, null, true)
}
};
using (Mocks.Record())
{
Expect.Call(providers[0].GetItems(bindingsPerProvider[0], true)).Return(itemsPerProvider[0]);
Expect.Call(providers[1].GetItems(bindingsPerProvider[1], true)).Return(itemsPerProvider[1]);
Expect.Call(providers[2].GetItems(bindingsPerProvider[2], true)).Return(itemsPerProvider[2]);
}
using (Mocks.Playback())
{
List<IList<IDataItem>> items = new List<IList<IDataItem>>(CombinatorialJoinStrategy.Instance.Join(providers, bindingsPerProvider, true));
Assert.Count(12, items);
int index = 0;
for (int i = 0; i < itemsPerProvider[0].Length; i++)
{
for (int j = 0; j < itemsPerProvider[1].Length; j++)
{
for (int k = 0; k < itemsPerProvider[2].Length; k++)
{
Assert.AreSame(itemsPerProvider[0][i], items[index][0]);
Assert.AreSame(itemsPerProvider[1][j], items[index][1]);
Assert.AreSame(itemsPerProvider[2][k], items[index][2]);
index += 1;
}
}
}
}
}
public ComparableDataItem(IDataItem dataItem)
{
if (dataItem == null)
throw new ArgumentNullException("dataItem");
this.dataItem = dataItem;
hash = GetDataItemHash(dataItem);
}
public Task WriteAsync(IDataItem dataItem, CancellationToken cancellation)
{
if (writeCallback != null)
writeCallback(dataItem);
receivedData.Add(dataItem);
return TaskHelper.NoOp;
}
/// <inheritdoc />
public override ContentDetailsViewModel CreateDetailsViewModel(IDataItem item)
{
var viewModel = base.CreateDetailsViewModel(item);
viewModel.ProviderName = this.GetManagerInstance().Provider.Name;
return viewModel;
}
public override void Fill(IDataItem item)
{
DataRow row = this.Current as DataRow;
if (row != null)
{
this.FillInternal (row,item);
}
}
public static double Open(IDataItem data)
{
System.Diagnostics.Debug.Assert(data != null);
if (data == null)
throw new ArgumentNullException();
return data.Open;
}
public static double MedianPrice(IDataItem data)
{
System.Diagnostics.Debug.Assert(data != null);
if (data == null)
throw new ArgumentNullException();
System.Diagnostics.Debug.Assert(((data.High + data.Low) / 2) == (((double)data.High + data.Low) / 2.0));
return (data.High + data.Low) / 2;
}
public static double WeightedPrice(IDataItem data)
{
System.Diagnostics.Debug.Assert(data != null);
if (data == null)
throw new ArgumentNullException();
System.Diagnostics.Debug.Assert(((data.High + data.Low + data.Close + data.Close) / 4) == (((double)data.High + data.Low + data.Close + data.Close) / 4.0));
return (data.High + data.Low + data.Close + data.Close) / 4;
}
public Item(IDataItem orig) {
foreach (var attr in orig.Attributes)
{
_attrs[attr.Name] = attr.Value;
}
foreach (var prop in orig.Properties)
{
_props[prop.Name] = new Property(prop);
}
}
/// <summary>
/// Returns the item content item defautl Url usign the location service
/// </summary>
/// <param name="helper">The Html helper</param>
/// <param name="item">The IDataItem for which the defautl Url will be searched</param>
/// /// <param name="alternativeUrl">Alternative Url of the dataItem. It will be used if the default Url is not resolved</param>
/// <returns>The default Url of the item</returns>
public static string GetItemDefaultUrl(this HtmlHelper helper, IDataItem item, string alternativeUrl = null)
{
// first we need to get an instance of the location service
var contentService = SystemManager.GetContentLocationService();
// use the location service to get the item location
var defaultLocation = contentService.GetItemDefaultLocation(item);
return UrlHtmlHelperExtensions.GetItemDefaultUrl(helper, defaultLocation, alternativeUrl);
}
protected static void VerifyDataItem(IReadOnlyDictionary<string, object> expected, IDataItem actual)
{
var actualColumns = actual.GetFieldNames().ToList();
foreach (var key in expected.Keys)
{
Assert.IsTrue(actualColumns.Contains(key), TestResources.PropertyMissingFormat, key);
Assert.AreEqual(expected[key], actual.GetValue(key), TestResources.InvalidPropertyValueFormat, key);
}
}
public static MvcHtmlString CommentsCount(this HtmlHelper helper, string navigateUrl, IDataItem item)
{
if (item == null)
return MvcHtmlString.Empty;
var contentItem = item as Content;
bool? allowComments = contentItem != null ? contentItem.AllowComments : null;
var threadKey = ControlUtilities.GetLocalizedKey(item.Id, null, CommentsBehaviorUtilities.GetLocalizedKeySuffix(item.GetType().FullName));
var itemTypeFullName = item.GetType().FullName;
return CommentsHelpers.CommentsCount(helper, navigateUrl, threadKey, itemTypeFullName, allowComments);
}
public void JoinsItemsSequentiallyAndPadsWithNullsUntilExhausted()
{
DataBinding[][] bindingsPerProvider = new DataBinding[][] {
new DataBinding[] { new DataBinding(0, null) },
new DataBinding[] { },
new DataBinding[] { new DataBinding(0, null) },
};
IDataProvider[] providers = new IDataProvider[] {
Mocks.StrictMock<IDataProvider>(),
Mocks.StrictMock<IDataProvider>(),
Mocks.StrictMock<IDataProvider>()
};
IDataItem[][] itemsPerProvider = new IDataItem[][] {
new IDataItem[] {
new ScalarDataItem<int>(1, null, true),
new ScalarDataItem<int>(2, null, false)
},
new IDataItem[] { },
new IDataItem[] {
new ScalarDataItem<int>(1, null, false),
new ScalarDataItem<int>(2, null, false),
new ScalarDataItem<int>(3, null, false)
}
};
using (Mocks.Record())
{
Expect.Call(providers[0].GetItems(bindingsPerProvider[0], true)).Return(itemsPerProvider[0]);
Expect.Call(providers[1].GetItems(bindingsPerProvider[1], true)).Return(itemsPerProvider[1]);
Expect.Call(providers[2].GetItems(bindingsPerProvider[2], true)).Return(itemsPerProvider[2]);
}
using (Mocks.Playback())
{
List<IList<IDataItem>> items = new List<IList<IDataItem>>(SequentialJoinStrategy.Instance.Join(providers, bindingsPerProvider, true));
Assert.Count(3, items);
Assert.AreSame(itemsPerProvider[0][0], items[0][0]);
Assert.AreSame(NullDataItem.Instance, items[0][1]);
Assert.AreSame(itemsPerProvider[2][0], items[0][2]);
Assert.AreSame(itemsPerProvider[0][1], items[1][0]);
Assert.AreSame(NullDataItem.Instance, items[1][1]);
Assert.AreSame(itemsPerProvider[2][1], items[1][2]);
Assert.AreSame(NullDataItem.Instance, items[2][0]);
Assert.AreSame(NullDataItem.Instance, items[2][1]);
Assert.AreSame(itemsPerProvider[2][2], items[2][2]);
}
}
public IDataItem Transform(IDataItem dataItem)
{
switch (handlingType)
{
case DateTimeHandling.String:
return new StringDateTimeDataItem(dataItem);
case DateTimeHandling.Epoch:
return new EpochDateTimeDataItem(dataItem);
case DateTimeHandling.Both:
return new StringAndEpochDateTimeDataItem(dataItem);
default:
return dataItem;
}
}
public void AddData(IDataItem item)
{
foreach (KeyValuePair<TimeFrame, IDataView> pair in DataViews)
{
DataView dv = pair.Value as DataView;
//Console.WriteLine("->Controller");
//Console.WriteLine(item);
//Console.WriteLine("<-Controller");
//Console.WriteLine();
dv.AddData(item);
}
ProcessingCompleted(this, new ProcessingCompletedEventArgs());
}
private static async Task TransferDataItem(IDataSinkAdapter sink, string dataItemId, IDataItem dataItem, ITransferStatistics statistics, CancellationToken cancellation)
{
try
{
await sink.WriteAsync(dataItem, cancellation);
statistics.AddTransferred();
}
catch (AggregateException aggregateException)
{
foreach (var exception in aggregateException.Flatten().InnerExceptions)
statistics.AddError(dataItemId, exception);
}
catch (Exception exception)
{
statistics.AddError(dataItemId, exception);
}
}
/// <inheritdoc />
public IEnumerable<IList<IDataItem>> Join(IList<IDataProvider> providers, IList<ICollection<DataBinding>> bindingsPerProvider,
bool includeDynamicItems)
{
int providerCount = providers.Count;
if (providerCount == 0)
yield break;
IEnumerable<IDataItem>[] sequences = new IEnumerable<IDataItem>[providers.Count];
for (int i = 0; i < providers.Count; i++)
sequences[i] = providers[i].GetItems(bindingsPerProvider[i], includeDynamicItems);
IEnumerator<IDataItem>[] enumerators = new IEnumerator<IDataItem>[providerCount];
enumerators[0] = sequences[0].GetEnumerator();
int enumeratorCount = 1;
for (; ; )
{
IEnumerator<IDataItem> top = enumerators[enumeratorCount - 1];
if (top.MoveNext())
{
if (enumeratorCount < providerCount)
{
enumerators[enumeratorCount] = sequences[enumeratorCount].GetEnumerator();
enumeratorCount += 1;
}
else
{
IDataItem[] itemList = new IDataItem[providerCount];
for (int i = 0; i < providerCount; i++)
itemList[i] = enumerators[i].Current;
yield return itemList;
}
}
else
{
enumeratorCount -= 1;
enumerators[enumeratorCount] = null;
if (enumeratorCount == 0)
break;
}
}
}
private static int GetDataItemHash(IDataItem dataItem)
{
var result = 0;
foreach (var fieldName in dataItem.GetFieldNames())
{
var value = dataItem.GetValue(fieldName);
if (value == null)
continue;
result ^= fieldName.GetHashCode() ^ (
value is IDataItem
? GetDataItemHash((IDataItem)value)
: GetValueHashCode(value));
}
return result;
}
protected static int Compare(IDataItem sourceItem, IDataItem targetItem)
{
if (sourceItem == null && targetItem == null)
{
return 0;
}
if (sourceItem == null)
{
return 1;
}
if (targetItem == null)
{
return -1;
}
return sourceItem.CompareTo(targetItem);
}
public override IList<ICommand> GenerateUpdateCommand(IDataItem dataItem)
{
var list = new List<ICommand>();
Assert.IsTrue(dataItem is ContentDataItem, "Incorrect item type. Probably problem with engine");
var target = dataItem as ContentDataItem;
Assert.IsNotNull(target, "DataItem");
if (CompareIds(target) != 0)
{
list.AddRange(this.GenerateDeleteCommand());
list.AddRange(target.GenerateAddCommand());
return list;
}
var item = new ChangeItemCommand(this, target);
if (!item.IsEmpty)
{
list.Add(item);
}
return list;
}
/// <summary>
/// put this item in the correct tables
/// </summary>
/// <param name="packet"></param>
/// <param name="item"></param>
/// <returns></returns>
protected override bool ProcessMessageAction(string packet, IDataItem item)
{
try
{
//get the mod field
long mod = (long)Convert.ChangeType(item.GetType().GetField(Table.ModField).GetValue(item), typeof(long));
long bucket = mod % ComputeNode.GlobalBucketCount;
//send the packet along
Catalog.Buckets[bucket].BucketDataTables[Table.TableName].AddOrUpdate(item.PrimaryKey, item);
Catalog.CatalogDataTables[Table.TableName].AddOrUpdate(item.PrimaryKey, item);
return true;
}
catch (Exception ex)
{
Trace.WriteLine(ex.ToString());
}
return false;
}
/// <summary>
/// send this packet along to the correct bermuda node to be saved
/// </summary>
/// <param name="packet"></param>
/// <param name="item"></param>
/// <returns></returns>
protected override bool ProcessMessageAction(string packet, IDataItem item)
{
try
{
//get the mod field
long mod = (long)Convert.ChangeType(item.GetType().GetField(Table.ModField).GetValue(item), typeof(long));
long bucket = mod % ComputeNode.GlobalBucketCount;
long instance = bucket % AddressMap.Count;
string address = AddressMap[instance];
//send the packet along
Client.Send(packet, address);
return true;
}
catch (Exception ex)
{
Trace.WriteLine(ex.ToString());
}
return false;
}
protected virtual void AddContentItemToRouteData(RequestContext requestContext, string redirectUrl, IDataItem item, bool setUrlParametersResolved = true)
{
requestContext.RouteData.Values[UrlParamsMapperBase.ActionNameKey] = this.actionName;
var parameters = this.ActionMethod.GetParameters();
if (parameters.Length > 0 && parameters[0].ParameterType.IsAssignableFrom(this.ItemType))
{
requestContext.RouteData.Values[parameters[0].ParameterName] = item;
}
if (!redirectUrl.IsNullOrEmpty())
{
requestContext.RouteData.Values[Telerik.Sitefinity.Mvc.ControllerActionInvoker.ShouldProcessRequestKey] = redirectUrl;
}
if (redirectUrl.IsNullOrEmpty() == false && parameters.Length > 1 && parameters[1].ParameterType == typeof(string))
{
requestContext.RouteData.Values[parameters[1].ParameterName] = redirectUrl;
}
if (setUrlParametersResolved)
{
RouteHelper.SetUrlParametersResolved();
}
}
public FilteredFieldsDataItem(IDataItem dataItem, ICollection <string> excludedFields)
: base(dataItem)
{
Guard.NotNull("excludedFields", excludedFields);
this.excludedFields = excludedFields;
}
public ModelFactorySingle(IDataItem data, string settingsJson, Manifest.Manifest manifest, TemplateManifest templateManifest, TemplateFiles templateFiles, OpenContentModuleConfig module) :
base(settingsJson, manifest, templateManifest, templateFiles, module)
{
this._dataJson = data.Data;
this._data = data;
}
/// <summary>
/// Perform a particular action.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action.</param>
/// <param name="item">The item to perform the action on.</param>
/// <param name="data">The additional data/parameters needed to perform the Action.</param>
/// <returns>Optionally return a JToken with a result value</returns>
/// <exception cref="System.NotImplementedException"></exception>
public virtual JToken Action(DataSourceContext context, string action, IDataItem item, JToken data)
{
throw new NotImplementedException();
}
/// <summary>
/// Puts a local notification to show calendar card
/// </summary>
/// <param name="dataItem">Data item.</param>
private async Task UpdateNotificationForDataItem(IDataItem dataItem)
{
if (Log.IsLoggable(Constants.TAG, LogPriority.Verbose))
{
Log.Verbose(Constants.TAG, "Updating notification for IDataItem");
}
DataMapItem mapDataItem = DataMapItem.FromDataItem(dataItem);
DataMap data = mapDataItem.DataMap;
String description = data.GetString(Constants.DESCRIPTION);
if (TextUtils.IsEmpty(description))
{
description = "";
}
else
{
// Add a space between the description and the time of the event
description += " ";
}
String contentText;
if (data.GetBoolean(Constants.ALL_DAY))
{
contentText = GetString(Resource.String.desc_all_day, description);
}
else
{
String startTime = DateFormat.GetTimeFormat(this).Format(new Date(data.GetLong(Constants.BEGIN)));
String endTime = DateFormat.GetTimeFormat(this).Format(new Date(data.GetLong(Constants.END)));
contentText = GetString(Resource.String.desc_time_period, description, startTime, endTime);
}
Intent deleteOperation = new Intent(this, typeof(DeleteService));
// Use a unique identifier for the delete action.
String deleteAction = "action_delete" + dataItem.Uri.ToString() + sNotificationId;
deleteOperation.SetAction(deleteAction);
deleteOperation.SetData(dataItem.Uri);
PendingIntent deleteIntent = PendingIntent.GetService(this, 0, deleteOperation, PendingIntentFlags.OneShot);
PendingIntent silentDeleteIntent = PendingIntent.GetService(this, 1, deleteOperation.PutExtra(Constants.EXTRA_SILENT, true), PendingIntentFlags.OneShot);
Notification.Builder notificationBuilder = new Notification.Builder(this)
.SetContentTitle(data.GetString(Constants.TITLE))
.SetContentText(contentText)
.SetSmallIcon(Resource.Drawable.ic_launcher)
.AddAction(Resource.Drawable.ic_menu_delete, GetText(Resource.String.delete), deleteIntent)
.SetDeleteIntent(silentDeleteIntent)
.SetLocalOnly(true)
.SetPriority((int)NotificationPriority.Min);
// Set the event owner's profile picture as the notification background
Asset asset = data.GetAsset(Constants.PROFILE_PIC);
if (asset != null)
{
if (mGoogleApiClient.IsConnected)
{
var assetFdResult = await WearableClass.DataApi.GetFdForAssetAsync(mGoogleApiClient, asset);
if (assetFdResult.Status.IsSuccess)
{
Bitmap profilePic = BitmapFactory.DecodeStream(assetFdResult.InputStream);
notificationBuilder.Extend(new Notification.WearableExtender().SetBackground(profilePic));
}
else if (Log.IsLoggable(Constants.TAG, LogPriority.Debug))
{
Log.Debug(Constants.TAG, "asset fetch failed with StatusCode: " + assetFdResult.Status.StatusCode);
}
}
else
{
Log.Error(Constants.TAG, "Failed to set notification background - Client disconnected from Google Play Services");
}
Notification card = notificationBuilder.Build();
(GetSystemService(Context.NotificationService).JavaCast <NotificationManager>()).Notify(sNotificationId, card);
sNotificationIdByDataItemUri.Add(dataItem.Uri, sNotificationId++);
}
}
public ConvertedDateTimeDataItemBase(IDataItem dataItem)
: base(dataItem)
{
}
private static XmlElement GetDataItemRow(XmlDocument document, int index, IDataItem param1, IDataItem param2, IDataItem result1, IDataItem result2)
{
var row = document.CreateElement("dataitem");
row.SetAttribute("index", index.ToString());
AppendElement(row, (param1.ToXmlElement(document, "param1")));
AppendElement(row, (param2.ToXmlElement(document, "param2")));
AppendElement(row, (result1.ToXmlElement(document, "result1")));
AppendElement(row, (result2.ToXmlElement(document, "result2")));
return(row);
}
public override bool IsLinkAllowed(IDataItem source, IDataItem target)
{
return(true);
}
/// <inheritdoc />
protected override object GetValueImpl(IDataItem item)
{
object value = item.GetValue(binding);
return(value);
}
public ConnectionsForm(IDataItem Node)
{
InitializeComponent();
try
{
emg = GetSession();
mpWindows = emg.ManagementPacks.GetManagementPack("Microsoft.Windows.Library", "31bf3856ad364e35", new Version());
mpAssetCore = emg.ManagementPacks.GetManagementPack("SMCenter.AssetManagement.Core", "75b45bd6835084b1", new Version());
mpNetworkAssetLibrary = emg.ManagementPacks.GetManagementPack("SMCenter.NetworkAssetManagement.Library", "75b45bd6835084b1", new Version());
mpNetworkLibrary = emg.GetManagementPack("System.NetworkManagement.Library", "31bf3856ad364e35", new Version());
mpCMLibrary = emg.ManagementPacks.GetManagementPack("Microsoft.SystemCenter.ConfigurationManager", "31bf3856ad364e35", new Version());
classModule = emg.EntityTypes.GetClass("SMCenter.Module", mpNetworkAssetLibrary);
classWindowsComputer = emg.EntityTypes.GetClass("SMCenter.WindowsComputer", mpNetworkAssetLibrary);
classDeployedComputer = emg.EntityTypes.GetClass("SMCenter.DeployedComputer", mpNetworkAssetLibrary);
classComputerNetworkAdapter = emg.EntityTypes.GetClass("Microsoft.Windows.ComputerNetworkAdapter", mpWindows);
classNode = emg.EntityTypes.GetClass("SMCenter.Node", mpNetworkAssetLibrary);
classNodePort = emg.EntityTypes.GetClass("SMCenter.NodePort", mpNetworkAssetLibrary);
classLocation = emg.EntityTypes.GetClass("SMCenter.Location", mpAssetCore);
classDevice = emg.EntityTypes.GetClass("SMCenter.Device", mpNetworkAssetLibrary);
classDeviceNetworkAdapter = emg.EntityTypes.GetClass("SMCenter.Device.NetworkAdapter", mpNetworkAssetLibrary);
classPatchPanel = emg.EntityTypes.GetClass("SMCenter.PatchPanel", mpNetworkAssetLibrary);
classPatchPanelPort = emg.EntityTypes.GetClass("SMCenter.PatchPanelPort", mpNetworkAssetLibrary);
relComputerRunsWindowsComputer = emg.EntityTypes.GetRelationshipClass("Microsoft.SystemCenter.ConfigurationManager.DeployedComputerRunsWindowsComputer", mpCMLibrary);
relComputerHostsComputerNetworkAdapter = emg.EntityTypes.GetRelationshipClass("Microsoft.Windows.ComputerHostsComputerNetworkAdapter", mpWindows);
relLoctoLoc = emg.EntityTypes.GetRelationshipClass("SMCenter.LocationContainsChildLocation", mpAssetCore);
//relNetworkAdapterHasChildNetworkAdapter = emg.EntityTypes.GetRelationshipClass("SMCenter.NetworkAdapterHasChildNetworkAdapter", mpNetworkAssetLibrary);
relChildNetworkAdapterRefParentNetworkAdapter = emg.EntityTypes.GetRelationshipClass("SMCenter.ChildNetworkAdapterRefParentNetworkAdapter", mpNetworkAssetLibrary);
//relLocationContainsConfigItem = emg.EntityTypes.GetRelationshipClass("SMCenter.LocationContainsConfigItem", mpAssetCore);
relConfigItemRefLocation = emg.EntityTypes.GetRelationshipClass("SMCenter.ConfigItemRefLocation", mpAssetCore);
relNodeComposedOfNetworkAdapter = emg.EntityTypes.GetRelationshipClass("System.NetworkManagement.NodeComposedOfNetworkAdapter", mpNetworkLibrary);
relDeviceHostNetworkAdapter = emg.EntityTypes.GetRelationshipClass("SMCenter.DeviceHostsNetworkAdapter", mpNetworkAssetLibrary);
this.ConnectionsTreeView.Items.Clear();
this.CabelsTreeView.Items.Clear();
TreeViewItem treeitem = new TreeViewItem();
LogFile = new LogFile(@"C:\LogFile.txt", true);
CablesTree = new CablesTree(emg, relChildNetworkAdapterRefParentNetworkAdapter, classModule, relConfigItemRefLocation, LogFile);
//Get CurrentNode
Guid CurrentNodeId = (Guid)Node["$Id$"];
EMO = emg.EntityObjects.GetObject <EnterpriseManagementObject>(CurrentNodeId, ObjectQueryOptions.Default);
this.txtTargetObject.Text = EMO.FullName;
Guid Id_NA = new Guid();
if (EMO.IsInstanceOf(classModule))
{
this.CabelsTreeView.Items.Add(CablesTree.CreateTreeViewItem(CurrentNodeId));
}
else if (EMO.IsInstanceOf(classWindowsComputer))
{
#region
var T_objects = emg.EntityObjects.GetRelationshipObjectsWhereSource <EnterpriseManagementObject>(CurrentNodeId, relComputerHostsComputerNetworkAdapter, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in T_objects)
{
Id_NA = relobj.TargetObject.Id;
}
this.CabelsTreeView.Items.Add(CablesTree.CreateTreeViewItem(Id_NA));
treeitem = ConnectionsTree.Create(Id_NA, emg);
if (treeitem != null)
{
this.ConnectionsTreeView.Items.Add(treeitem);
}
#endregion
}
else if (EMO.IsInstanceOf(classDeployedComputer))
{
#region
ObservableCollection <Guid> GuidCol = new ObservableCollection <Guid>();
var T_objects = emg.EntityObjects.GetRelationshipObjectsWhereSource <EnterpriseManagementObject>(CurrentNodeId, relComputerRunsWindowsComputer, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in T_objects)
{
GuidCol.Add(relobj.TargetObject.Id);
}
//Для каждого WindowsComputer ищем свой NetworkAdapter
foreach (Guid id in GuidCol)
{
T_objects = emg.EntityObjects.GetRelationshipObjectsWhereSource <EnterpriseManagementObject>(id, relComputerHostsComputerNetworkAdapter, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in T_objects)
{
Id_NA = relobj.TargetObject.Id;
}
this.CabelsTreeView.Items.Add(CablesTree.Go(Id_NA));
treeitem = ConnectionsTree.Create(Id_NA, emg);
if (treeitem != null)
{
this.ConnectionsTreeView.Items.Add(treeitem);
}
}
#endregion
}
else if (EMO.IsInstanceOf(classNode))
{
#region
ObservableCollection <Guid> GuidCol = new ObservableCollection <Guid>();
var T_objects = emg.EntityObjects.GetRelationshipObjectsWhereSource <EnterpriseManagementObject>(CurrentNodeId, relNodeComposedOfNetworkAdapter, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in T_objects)
{
GuidCol.Add(relobj.TargetObject.Id);
}
foreach (Guid id in GuidCol)
{
this.CabelsTreeView.Items.Add(CablesTree.Go(id));
treeitem = ConnectionsTree.Create(id, emg);
if (treeitem != null)
{
this.ConnectionsTreeView.Items.Add(treeitem);
}
}
#endregion
}
else if (EMO.IsInstanceOf(classNodePort))
{
this.CabelsTreeView.Items.Add(CablesTree.Go(CurrentNodeId));
treeitem = ConnectionsTree.Create(CurrentNodeId, emg);
if (treeitem != null)
{
this.ConnectionsTreeView.Items.Add(treeitem);
}
}
else if (EMO.IsInstanceOf(classDevice))
{
#region
var T_objects = emg.EntityObjects.GetRelationshipObjectsWhereSource <EnterpriseManagementObject>(CurrentNodeId, relDeviceHostNetworkAdapter, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in T_objects)
{
Id_NA = relobj.TargetObject.Id;
}
this.CabelsTreeView.Items.Add(CablesTree.Go(Id_NA));
treeitem = ConnectionsTree.Create(Id_NA, emg);
if (treeitem != null)
{
this.ConnectionsTreeView.Items.Add(treeitem);
}
#endregion
}
else if (EMO.IsInstanceOf(classDeviceNetworkAdapter))
{
this.CabelsTreeView.Items.Add(CablesTree.Go(CurrentNodeId));
treeitem = ConnectionsTree.Create(CurrentNodeId, emg);
if (treeitem != null)
{
this.ConnectionsTreeView.Items.Add(treeitem);
}
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show("Initialize procedure error : " + ex.Message, "Service Manager", MessageBoxButton.OK, MessageBoxImage.Error);
this.Close();
}
}
private void CabelsTreeView_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
TreeViewItem SelectedTreeItem = (TreeViewItem)this.CabelsTreeView.SelectedItem;
if (SelectedTreeItem.Header.ToString().Contains("Cable.Footage"))
{
}
else
{
//Get CurrentNode
Guid G = new Guid(SelectedTreeItem.Tag.ToString());
EMO = emg.EntityObjects.GetObject <EnterpriseManagementObject>(G, ObjectQueryOptions.Default);
//Guid Id_NA = new Guid();
if (EMO.IsInstanceOf(classModule))
{
EnterpriseManagementObjectDataType dataType = new EnterpriseManagementObjectDataType(classModule);
IDataItem itemIdentity = dataType.CreateProxyInstance(EMO);
Microsoft.EnterpriseManagement.GenericForm.FormUtilities.Instance.PopoutForm(itemIdentity);
}
else if (EMO.IsInstanceOf(classNodePort))
{
var items = emg.EntityObjects.GetRelationshipObjectsWhereTarget <EnterpriseManagementObject>(G, relNodeComposedOfNetworkAdapter, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in items)
{
EMO = relobj.SourceObject;
}
EnterpriseManagementObjectDataType dataType = new EnterpriseManagementObjectDataType(classNode);
IDataItem itemIdentity = dataType.CreateProxyInstance(EMO);
Microsoft.EnterpriseManagement.GenericForm.FormUtilities.Instance.PopoutForm(itemIdentity);
}
else if (EMO.IsInstanceOf(classDeviceNetworkAdapter))
{
var items = emg.EntityObjects.GetRelationshipObjectsWhereTarget <EnterpriseManagementObject>(G, relDeviceHostNetworkAdapter, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in items)
{
EMO = relobj.SourceObject;
}
EnterpriseManagementObjectDataType dataType = new EnterpriseManagementObjectDataType(classDevice);
IDataItem itemIdentity = dataType.CreateProxyInstance(EMO);
Microsoft.EnterpriseManagement.GenericForm.FormUtilities.Instance.PopoutForm(itemIdentity);
}
else if (EMO.IsInstanceOf(classComputerNetworkAdapter))
{
var items = emg.EntityObjects.GetRelationshipObjectsWhereTarget <EnterpriseManagementObject>(G, relComputerHostsComputerNetworkAdapter, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in items)
{
EMO = relobj.SourceObject;
}
EnterpriseManagementObjectDataType dataType = new EnterpriseManagementObjectDataType(classWindowsComputer);
IDataItem itemIdentity = dataType.CreateProxyInstance(EMO);
Microsoft.EnterpriseManagement.GenericForm.FormUtilities.Instance.PopoutForm(itemIdentity);
}
else if (EMO.IsInstanceOf(classPatchPanelPort))
{
var items = emg.EntityObjects.GetRelationshipObjectsWhereTarget <EnterpriseManagementObject>(G, relNodeComposedOfNetworkAdapter, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> relobj in items)
{
EMO = relobj.SourceObject;
}
EnterpriseManagementObjectDataType dataType = new EnterpriseManagementObjectDataType(classPatchPanel);
IDataItem itemIdentity = dataType.CreateProxyInstance(EMO);
Microsoft.EnterpriseManagement.GenericForm.FormUtilities.Instance.PopoutForm(itemIdentity);
}
else
{
System.Windows.MessageBox.Show("Unknown object!");
}
}
}
private void btnOpen_Click_SoftwareAgreement(object sender, RoutedEventArgs e)
{
IDataItem emoProjectionObject = (IDataItem)SoftwareAgreement.SelectedItem;
Microsoft.EnterpriseManagement.GenericForm.FormUtilities.Instance.PopoutForm(emoProjectionObject);
}
/// <summary>
/// Creates an instance of the item view model by given data item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
protected virtual ItemViewModel CreateItemViewModelInstance(IDataItem item)
{
return(new ItemViewModel(item));
}
/// <summary>
/// An IDataItem extension method that gets a manager.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>
/// The manager.
/// </returns>
public static IManager GetManager(this IDataItem item)
{
return(ManagerBase.GetMappedManager(item.GetType()));
}
public void DeleteItem(IDataItem item)
{
this.data.UsersRepository.Delete((User)item);
}
public void UpdateItem(IDataItem item)
{
this.data.UsersRepository.Update((User)item);
}
public IDataItem Transform(IDataItem dataItem)
{
Guard.NotNull("dataItem", dataItem);
return(new FilteredFieldsDataItem(dataItem, excludedFields));
}
public static bool?LaunchDialog(String strWindowTitle, ref IDataItem dataitemMessageType, ref IDataItem dataItemIncidentStatus, out String strMessage, out Boolean boolAddToActionLog)
{
WizardStory wizardStory = new WizardStory();
SendEmailWizardData wizardData = new SendEmailWizardData();
wizardStory.WizardData = wizardData;
wizardStory.AddLast(new WizardStep(strWindowTitle, typeof(SendEmailForm), wizardStory.WizardData));
TabbedPropertySheetDialog propertyDialog = new TabbedPropertySheetDialog(wizardStory);
propertyDialog.Width = 350;
propertyDialog.Height = 350;
propertyDialog.MinWidth = 350;
propertyDialog.MinHeight = 350;
propertyDialog.ResizeMode = ResizeMode.CanResizeWithGrip;
propertyDialog.Title = strWindowTitle;
wizardData.IncidentStatus = dataItemIncidentStatus;
wizardData.AddToActionLog = true;
bool?result = propertyDialog.ShowDialog();
strMessage = wizardData.Message;
dataitemMessageType = wizardData.MessageType;
dataItemIncidentStatus = wizardData.IncidentStatus;
boolAddToActionLog = wizardData.AddToActionLog;
return(result);
}
public void DeleteItem(IDataItem item)
{
this.data.FuelsRepository.Delete((Fuel)item);
}
protected override object GetValue(string key)
{
IDataItem target = _dataItems.FirstOrDefault(d => d.Name == key);
return(target?.Value);
}
public void UpdateItem(IDataItem item)
{
this.data.FuelsRepository.Update((Fuel)item);
}
protected abstract override IDataItem TransformDataItem(IDataItem original);
private void MouseDoubleClick_Subnet(object sender, MouseButtonEventArgs e)
{
IDataItem emoProjectionObject = (IDataItem)Subnet.SelectedItem;
Microsoft.EnterpriseManagement.GenericForm.FormUtilities.Instance.PopoutForm(emoProjectionObject);
}
public ModelFactorySingle(IDataItem data, OpenContentModuleConfig module, string collection) :
base(module, collection)
{
this._dataJson = data.Data;
this._data = data;
}
public bool Contains(IDataItem <T> item)
{
return(_items.ContainsKey(item.ID) || _index.ContainsKey(item.Name));
}
public bool Remove(IDataItem <T> item)
{
return(_items.Remove(item.ID) && _index.Remove(item.Name));
}
private IComparableDataItem GetFieldsValues(IEnumerable <FieldInfoPair> fieldPairs, IDataItem item)
{
var groupingPair = new GroupingPair();
foreach (var fieldPair in fieldPairs)
{
var value = item.GetValueOrDefault(fieldPair.OutputName, item);
groupingPair[fieldPair.OutputName] = value;
}
return(groupingPair);
}
protected bool insertList(IDataItem cols, List <GetHandler> valuesList)
{
if (valuesList == null || valuesList.Count == 0)
{
return(false);
}
if (cols == null || cols.count() == 0)
{
return(false);
}
List <Object> args = new List <Object>();
StringBuilder sb = new StringBuilder();
sb.Append(" INSERT INTO ").Append(_table).Append(" (");
foreach (String key in cols.keys())
{
sb.Append(_context.field(key)).Append(",");
}
sb.DeleteCharAt(sb.Length - 1);
sb.Append(") ");
sb.Append("VALUES");
foreach (GetHandler item in valuesList)
{
sb.Append("(");
foreach (String key in cols.keys())
{
Object val = item(key);
if (val is String)
{
String val2 = (String)val;
if (val2.IndexOf('$') == 0) //说明是SQL函数
{
sb.Append(val2.Substring(1)).Append(",");
}
else
{
sb.Append("?,");
args.Add(val);
}
}
else
{
sb.Append("?,");
args.Add(val);
}
}
sb.DeleteCharAt(sb.Length - 1);
sb.Append("),");
}
sb.DeleteCharAt(sb.Length - 1);
sb.Append(");");
_builder.append(sb.ToString(), args.ToArray());
return(compile().execute() > 0);
}
public override bool IsDataItemValid(IDataItem dataItem)
{
return(true);
}
public override void Fill(IDataItem item)
{
if (current != null) {
BaseDataItem baseDataItem = item as BaseDataItem;
if (baseDataItem != null) {
PropertyDescriptor p = this.listProperties.Find(baseDataItem.ColumnName, true);
if (p != null) {
baseDataItem.DBValue = p.GetValue(this.Current).ToString();
} else {
baseDataItem.DBValue = string.Format(CultureInfo.InvariantCulture,"<{0}> missing!", baseDataItem.ColumnName);
}
return;
}
//image processing from IList
BaseImageItem baseImageItem = item as BaseImageItem;
if (baseImageItem != null) {
PropertyDescriptor p = this.listProperties.Find(baseImageItem.ColumnName, true);
if (p != null) {
baseImageItem.Image = p.GetValue(this.Current) as System.Drawing.Image;
}
return;
}
}
}
/// <inheritdoc />
protected override ItemViewModel CreateItemViewModelInstance(IDataItem item)
{
return(new VideoThumbnailViewModel(item));
}
