service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/view/ResourceManagerView.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package oic.simulator.serviceprovider.view;
  18
  19 import java.util.ArrayList;
  20 import java.util.List;
  21
  22 import oic.simulator.serviceprovider.Activator;
  23 import oic.simulator.serviceprovider.listener.IResourceListChangedUIListener;
  24 import oic.simulator.serviceprovider.manager.ResourceManager;
  25 import oic.simulator.serviceprovider.resource.DeleteCategory;
  26 import oic.simulator.serviceprovider.utils.Constants;
  27 import oic.simulator.serviceprovider.utils.Utility;
  28 import oic.simulator.serviceprovider.view.dialogs.CreateResourceWizard;
  29 import oic.simulator.serviceprovider.view.dialogs.DeleteResourceWizard;
  30 import oic.simulator.serviceprovider.view.dialogs.ResourceWizardDialog;
  31
  32 import org.eclipse.jface.dialogs.MessageDialog;
  33 import org.eclipse.jface.viewers.ITreeContentProvider;
  34 import org.eclipse.jface.viewers.LabelProvider;
  35 import org.eclipse.jface.viewers.TreeViewer;
  36 import org.eclipse.jface.viewers.Viewer;
  37 import org.eclipse.jface.wizard.WizardDialog;
  38 import org.eclipse.swt.SWT;
  39 import org.eclipse.swt.events.MenuAdapter;
  40 import org.eclipse.swt.events.MenuEvent;
  41 import org.eclipse.swt.events.SelectionAdapter;
  42 import org.eclipse.swt.events.SelectionEvent;
  43 import org.eclipse.swt.graphics.Color;
  44 import org.eclipse.swt.graphics.Image;
  45 import org.eclipse.swt.layout.GridData;
  46 import org.eclipse.swt.layout.GridLayout;
  47 import org.eclipse.swt.widgets.Button;
  48 import org.eclipse.swt.widgets.Composite;
  49 import org.eclipse.swt.widgets.Display;
  50 import org.eclipse.swt.widgets.Group;
  51 import org.eclipse.swt.widgets.Menu;
  52 import org.eclipse.swt.widgets.MenuItem;
  53 import org.eclipse.swt.widgets.Tree;
  54 import org.eclipse.swt.widgets.TreeItem;
  55 import org.eclipse.ui.PlatformUI;
  56 import org.eclipse.ui.dialogs.FilteredTree;
  57 import org.eclipse.ui.dialogs.PatternFilter;
  58 import org.eclipse.ui.part.ViewPart;
  59
  60 /**
  61  * This class manages and shows the resource manager view in the perspective.
  62  */
  63 public class ResourceManagerView extends ViewPart {
  64
  65     public static final String             VIEW_ID = "oic.simulator.serviceprovider.view.resourcemanager";
  66
  67     private Button                         createButton;
  68     private Button                         deleteButton;
  69
  70     private TreeViewer                     treeViewer;
  71
  72     private IResourceListChangedUIListener resourceListChangedListener;
  73
  74     private ResourceManager                resourceManager;
  75
  76     public ResourceManagerView() {
  77
  78         resourceManager = Activator.getDefault().getResourceManager();
  79
  80         resourceListChangedListener = new IResourceListChangedUIListener() {
  81
  82             @Override
  83             public void onResourceCreation() {
  84                 Display.getDefault().asyncExec(new Runnable() {
  85
  86                     @Override
  87                     public void run() {
  88                         if (null != treeViewer) {
  89                             treeViewer.refresh();
  90                         }
  91
  92                         // Trigger the visibility of delete button
  93                         changeDeleteVisibility();
  94                     }
  95                 });
  96             }
  97
  98             @Override
  99             public void onResourceDeletion() {
 100                 Display.getDefault().asyncExec(new Runnable() {
 101
 102                     @Override
 103                     public void run() {
 104                         if (null != treeViewer) {
 105                             treeViewer.refresh();
 106                         }
 107
 108                         // Trigger the visibility of delete button
 109                         changeDeleteVisibility();
 110                     }
 111                 });
 112             }
 113         };
 114     }
 115
 116     public void changeDeleteVisibility() {
 117         if (null == treeViewer) {
 118             return;
 119         }
 120         boolean visibility;
 121         Tree tree = treeViewer.getTree();
 122         if (null != tree && !tree.isDisposed() && tree.getItemCount() > 0) {
 123             visibility = true;
 124         } else {
 125             visibility = false;
 126         }
 127         if (null != deleteButton && !deleteButton.isDisposed()) {
 128             deleteButton.setEnabled(visibility);
 129         }
 130     }
 131
 132     @Override
 133     public void createPartControl(Composite parent) {
 134         Composite compContent = new Composite(parent, SWT.NONE);
 135         GridLayout baseLayout = new GridLayout(1, false);
 136         compContent.setLayout(baseLayout);
 137
 138         GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 139         compContent.setLayoutData(gd);
 140
 141         Composite buttonComp = new Composite(compContent, SWT.NONE);
 142         buttonComp.setLayout(new GridLayout(2, false));
 143
 144         gd = new GridData();
 145         gd.horizontalAlignment = SWT.FILL;
 146         gd.grabExcessHorizontalSpace = true;
 147
 148         buttonComp.setLayoutData(gd);
 149
 150         createButton = new Button(buttonComp, SWT.PUSH);
 151         createButton.setText("Create");
 152         createButton.setToolTipText("Create Simulator Resource(s)");
 153
 154         gd = new GridData();
 155         gd.widthHint = 90;
 156         createButton.setLayoutData(gd);
 157
 158         deleteButton = new Button(buttonComp, SWT.PUSH);
 159         deleteButton.setText("Delete");
 160         deleteButton.setToolTipText("Delete Simulator Resource(s)");
 161
 162         gd = new GridData();
 163         gd.widthHint = 90;
 164         deleteButton.setLayoutData(gd);
 165
 166         Group resourceGroup = new Group(compContent, SWT.NONE);
 167         resourceGroup.setText("Created Resources");
 168
 169         Color color = Display.getDefault().getSystemColor(SWT.COLOR_WHITE);
 170         resourceGroup.setBackground(color);
 171
 172         resourceGroup.setLayout(new GridLayout(1, false));
 173         gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 174         resourceGroup.setLayoutData(gd);
 175
 176         PatternFilter filter = new PatternFilter();
 177         FilteredTree filteredTree = new FilteredTree(resourceGroup,
 178                 SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE, filter, true);
 179         treeViewer = filteredTree.getViewer();
 180         treeViewer.getTree().setLayoutData(
 181                 new GridData(SWT.FILL, SWT.FILL, true, true));
 182         treeViewer.setContentProvider(new TreeContentProvider());
 183         treeViewer.setLabelProvider(new TreeLabelProvider());
 184         treeViewer.setInput(new Object());
 185
 186         addUIListeners();
 187
 188         addManagerListeners();
 189
 190         // If there is at least one resource exist, then enable the delete
 191         // resource button
 192         changeDeleteVisibility();
 193     }
 194
 195     private void addUIListeners() {
 196
 197         createButton.addSelectionListener(new SelectionAdapter() {
 198             @Override
 199             public void widgetSelected(SelectionEvent e) {
 200                 PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 201
 202                     @Override
 203                     public void run() {
 204                         CreateResourceWizard createWizard = new CreateResourceWizard();
 205                         ResourceWizardDialog wizardDialog = new ResourceWizardDialog(
 206                                 PlatformUI.getWorkbench().getDisplay()
 207                                         .getActiveShell(), createWizard);
 208                         int open = wizardDialog.open();
 209                         if (open == WizardDialog.OK) {
 210                             String configFilePath;
 211                             int count;
 212                             configFilePath = createWizard.getConfigFilePath();
 213                             System.out.println("Resultant config file path is "
 214                                     + configFilePath);
 215                             count = createWizard.getResourceCount();
 216                             if (count > 0) {
 217                                 if (count == 1) {
 218                                     // Single resource creation
 219                                     resourceManager
 220                                             .createResource(configFilePath);
 221                                 } else {
 222                                     // Multi-resource creation
 223                                     resourceManager.createResource(
 224                                             configFilePath, count);
 225                                 }
 226                             }
 227                         }
 228                     }
 229                 });
 230             }
 231         });
 232
 233         deleteButton.addSelectionListener(new SelectionAdapter() {
 234             @Override
 235             public void widgetSelected(SelectionEvent e) {
 236                 PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 237
 238                     @Override
 239                     public void run() {
 240                         DeleteResourceWizard deleteWizard = new DeleteResourceWizard();
 241                         ResourceWizardDialog wizardDialog = new ResourceWizardDialog(
 242                                 PlatformUI.getWorkbench().getDisplay()
 243                                         .getActiveShell(), deleteWizard);
 244                         int open = wizardDialog.open();
 245                         if (open == WizardDialog.OK) {
 246                             DeleteCategory deleteCategory = deleteWizard
 247                                     .getDeleteCategory();
 248                             if (deleteCategory == DeleteCategory.BY_URI) {
 249                                 String uri = deleteWizard.getDeleteCandidate();
 250                                 if (null != uri) {
 251                                     boolean dispName = Activator.getDefault()
 252                                             .getResourceManager()
 253                                             .isDisplayName(uri);
 254                                     if (dispName) {
 255                                         uri = Activator
 256                                                 .getDefault()
 257                                                 .getResourceManager()
 258                                                 .getCompleteUriFromDisplayName(
 259                                                         uri);
 260                                     }
 261                                     resourceManager.deleteResourceByURI(uri);
 262                                 }
 263                             } else if (deleteCategory == DeleteCategory.BY_TYPE) {
 264                                 resourceManager
 265                                         .deleteResourceByType(deleteWizard
 266                                                 .getDeleteCandidate());
 267                             } else if (deleteCategory == DeleteCategory.ALL) {
 268                                 resourceManager.deleteAllResources();
 269                             }
 270                         }
 271                     }
 272                 });
 273             }
 274         });
 275
 276         if (null != treeViewer) {
 277             final Tree resourceTreeHead = treeViewer.getTree();
 278             if (null != resourceTreeHead) {
 279                 // Below code adds a listener to the tree for selection changes
 280                 // and notifies the resource manager
 281                 resourceTreeHead.addSelectionListener(new SelectionAdapter() {
 282                     @Override
 283                     public void widgetSelected(SelectionEvent e) {
 284                         TreeItem selectedItem = (TreeItem) e.item;
 285                         if (null != selectedItem) {
 286                             String selectedItemText = selectedItem.getText();
 287                             selectedItemText = resourceManager
 288                                     .getCompleteUriFromDisplayName(selectedItemText);
 289                             // Propagate this selection change event to manager
 290                             resourceManager
 291                                     .resourceSelectionChanged(selectedItemText);
 292                         }
 293                     }
 294                 });
 295                 // Below code creates menu entries and shows them on right
 296                 // clicking a resource
 297                 final Menu menu = new Menu(resourceTreeHead);
 298                 resourceTreeHead.setMenu(menu);
 299                 menu.addMenuListener(new MenuAdapter() {
 300                     @Override
 301                     public void menuShown(MenuEvent e) {
 302                         // Clear existing menu items
 303                         MenuItem[] items = menu.getItems();
 304                         for (int index = 0; index < items.length; index++) {
 305                             items[index].dispose();
 306                         }
 307                         final String selectedItem = resourceTreeHead
 308                                 .getSelection()[0].getText();
 309                         MenuItem startItem = new MenuItem(menu, SWT.NONE);
 310                         startItem.setText(Constants.START_RESOURCE_AUTOMATION);
 311                         startItem.addSelectionListener(new SelectionAdapter() {
 312                             @Override
 313                             public void widgetSelected(SelectionEvent e) {
 314                                 // Block starting resource level
 315                                 // automation if any attribute level
 316                                 // automation is in progress for the
 317                                 // selected resource
 318                                 boolean started = resourceManager
 319                                         .isAttributeAutomationStarted(resourceManager
 320                                                 .getCompleteUriFromDisplayName(selectedItem));
 321                                 if (started) {
 322                                     MessageDialog
 323                                             .openInformation(
 324                                                     Display.getDefault()
 325                                                             .getActiveShell(),
 326                                                     "Attribute automation is in progress",
 327                                                     "Attribute level automation for this resource is already in progress!!!\nPlease stop all "
 328                                                             + "running attribute level automations to start resource level automation.");
 329                                 } else {
 330                                     boolean status = resourceManager
 331                                             .startResourceAutomationUIRequest(resourceManager
 332                                                     .getCompleteUriFromDisplayName(selectedItem));
 333                                     String statusMsg = status ? "Automation started successfully!!!"
 334                                             : "Automation request failed!!!";
 335                                     MessageDialog.openInformation(Display
 336                                             .getDefault().getActiveShell(),
 337                                             "Automation Status", statusMsg);
 338                                 }
 339                             }
 340                         });
 341
 342                         MenuItem stopItem = new MenuItem(menu, SWT.NONE);
 343                         stopItem.setText(Constants.STOP_RESOURCE_AUTOMATION);
 344                         stopItem.addSelectionListener(new SelectionAdapter() {
 345                             @Override
 346                             public void widgetSelected(SelectionEvent e) {
 347                                 boolean status = resourceManager
 348                                         .stopResourceAutomationUIRequest(resourceManager
 349                                                 .getCompleteUriFromDisplayName(selectedItem));
 350                                 String statusMsg = status ? "Automation stop requested!!!"
 351                                         : "Automation stop failed.";
 352                                 MessageDialog.openInformation(Display
 353                                         .getDefault().getActiveShell(),
 354                                         "Automation Status", statusMsg);
 355                             }
 356                         });
 357
 358                         // Set the initial visibility of menu items
 359                         boolean status = resourceManager.isResourceAutomationStarted(resourceManager
 360                                 .getCompleteUriFromDisplayName(selectedItem));
 361                         startItem.setEnabled(!status);
 362                         stopItem.setEnabled(status);
 363                     }
 364                 });
 365             }
 366         }
 367     }
 368
 369     public void addManagerListeners() {
 370         resourceManager
 371                 .addResourceListChangedUIListener(resourceListChangedListener);
 372     }
 373
 374     @Override
 375     public void setFocus() {
 376     }
 377
 378     @Override
 379     public void dispose() {
 380         // Unregister the listener
 381         if (null != resourceListChangedListener) {
 382             resourceManager
 383                     .removeResourceListChangedUIListener(resourceListChangedListener);
 384             resourceManager.resourceSelectionChanged(null);
 385         }
 386         super.dispose();
 387     }
 388 }
 389
 390 class TreeContentProvider implements ITreeContentProvider {
 391
 392     @Override
 393     public void dispose() {
 394     }
 395
 396     @Override
 397     public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
 398     }
 399
 400     @Override
 401     public Object[] getChildren(Object parent) {
 402         return null;
 403     }
 404
 405     @Override
 406     public Object[] getElements(Object parent) {
 407         List<String> uriList;
 408         uriList = Activator.getDefault().getResourceManager().getURIList();
 409         if (null == uriList) {
 410             uriList = new ArrayList<String>();
 411         }
 412         return uriList.toArray();
 413     }
 414
 415     @Override
 416     public Object getParent(Object child) {
 417         return null;
 418     }
 419
 420     @Override
 421     public boolean hasChildren(Object parent) {
 422         return false;
 423     }
 424 }
 425
 426 class TreeLabelProvider extends LabelProvider {
 427     @Override
 428     public String getText(Object element) {
 429         String value = (String) element;
 430         value = Utility.uriToDisplayName(value);
 431         return value;
 432     }
 433
 434     @Override
 435     public Image getImage(Object element) {
 436         ResourceManager resourceManager = Activator.getDefault()
 437                 .getResourceManager();
 438         return resourceManager.getImage((String) element);
 439     }
 440 }