service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/view/dialogs/CreateResourceWizard.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.dialogs;
  18
  19 import java.lang.reflect.InvocationTargetException;
  20 import java.net.URL;
  21 import java.util.Date;
  22 import java.util.HashMap;
  23 import java.util.Iterator;
  24 import java.util.Map;
  25 import java.util.Set;
  26
  27 import oic.simulator.serviceprovider.Activator;
  28 import oic.simulator.serviceprovider.manager.UiListenerHandler;
  29 import oic.simulator.serviceprovider.model.AttributeHelper;
  30 import oic.simulator.serviceprovider.model.CollectionResource;
  31 import oic.simulator.serviceprovider.model.LocalResourceAttribute;
  32 import oic.simulator.serviceprovider.model.Resource;
  33 import oic.simulator.serviceprovider.model.ResourceType;
  34 import oic.simulator.serviceprovider.model.SingleResource;
  35 import oic.simulator.serviceprovider.utils.Utility;
  36 import oic.simulator.serviceprovider.view.dialogs.MainPage.ResourceOption;
  37
  38 import org.eclipse.core.runtime.FileLocator;
  39 import org.eclipse.core.runtime.IPath;
  40 import org.eclipse.core.runtime.IProgressMonitor;
  41 import org.eclipse.core.runtime.Path;
  42 import org.eclipse.jface.dialogs.MessageDialog;
  43 import org.eclipse.jface.operation.IRunnableWithProgress;
  44 import org.eclipse.jface.resource.ImageDescriptor;
  45 import org.eclipse.jface.wizard.IWizardPage;
  46 import org.eclipse.jface.wizard.Wizard;
  47 import org.eclipse.jface.wizard.WizardDialog;
  48 import org.oic.simulator.ILogger.Level;
  49 import org.oic.simulator.SimulatorException;
  50
  51 /**
  52  * This class creates a UI wizard for create resource operation.
  53  */
  54 public class CreateResourceWizard extends Wizard {
  55
  56     private MainPage                           mainPage;
  57     private SimpleResourceBasicDetailsPage     simpleResourceBasicDetailsPage;
  58     private SimpleResourceAddAttributePage     simpleResourceAddAttributePage;
  59     private SimpleResourceOtherDetailsPage     simpleResourceOtherDetailsPage;
  60     private CollectionResourceBasicDetailsPage collectionResourceBasicDetailsPage;
  61     private AddResourcesToCollectionPage       addResourcesToCollectionPage;
  62     private LoadRamlPage                       loadRamlPage;
  63     private UpdatePropertiesPage               updatePropPage;
  64     private DevicePage                         devicePage;
  65     private StartStopResourcePage              startStopPage;
  66
  67     // private SingleResource simResource;
  68     private String                             status;
  69
  70     private WizardDialog                       wizDialog;
  71     private boolean                            dlgForceClosed;
  72
  73     public CreateResourceWizard() {
  74         setWindowTitle("Create resources");
  75         IPath path = new Path("/icons/oic_logo_64x64.png");
  76         URL find = FileLocator.find(Activator.getDefault().getBundle(), path,
  77                 null);
  78         setDefaultPageImageDescriptor(ImageDescriptor.createFromURL(find));
  79
  80         setNeedsProgressMonitor(true);
  81     }
  82
  83     @Override
  84     public void addPages() {
  85         mainPage = new MainPage();
  86         simpleResourceBasicDetailsPage = new SimpleResourceBasicDetailsPage();
  87         simpleResourceAddAttributePage = new SimpleResourceAddAttributePage();
  88         simpleResourceOtherDetailsPage = new SimpleResourceOtherDetailsPage();
  89         collectionResourceBasicDetailsPage = new CollectionResourceBasicDetailsPage();
  90         addResourcesToCollectionPage = new AddResourcesToCollectionPage();
  91         loadRamlPage = new LoadRamlPage();
  92         updatePropPage = new UpdatePropertiesPage();
  93         devicePage = new DevicePage();
  94         startStopPage = new StartStopResourcePage();
  95
  96         addPage(mainPage);
  97         addPage(simpleResourceBasicDetailsPage);
  98         addPage(simpleResourceAddAttributePage);
  99         addPage(simpleResourceOtherDetailsPage);
 100         addPage(collectionResourceBasicDetailsPage);
 101         if (Activator.getDefault().getResourceManager().isAnyResourceExist())
 102             addPage(addResourcesToCollectionPage);
 103         addPage(loadRamlPage);
 104         addPage(updatePropPage);
 105         addPage(devicePage);
 106         addPage(startStopPage);
 107     }
 108
 109     public void setWizardDialog(WizardDialog dlg) {
 110         wizDialog = dlg;
 111     }
 112
 113     public WizardDialog getWizardDialog() {
 114         return wizDialog;
 115     }
 116
 117     public boolean isDlgForceClosed() {
 118         return dlgForceClosed;
 119     }
 120
 121     public void setDlgForceClosed(boolean dlgForceClosed) {
 122         this.dlgForceClosed = dlgForceClosed;
 123     }
 124
 125     public String getConfigFilePath() {
 126         if (null == loadRamlPage) {
 127             return null;
 128         }
 129         return loadRamlPage.getConfigFilePath();
 130     }
 131
 132     public int getResourceCount() {
 133         if (null == loadRamlPage) {
 134             return 0;
 135         }
 136         return loadRamlPage.getResourceCount();
 137     }
 138
 139     @Override
 140     public boolean canFinish() {
 141         System.out.println("canFinish()");
 142         IWizardPage curPage = this.getContainer().getCurrentPage();
 143         System.out.println(curPage.getName());
 144         if ((curPage == updatePropPage && ((mainPage.getResourceOption() == ResourceOption.SIMPLE_FROM_RAML) || !Activator
 145                 .getDefault().getResourceManager().isAnyResourceExist()))
 146                 || (curPage == collectionResourceBasicDetailsPage
 147                         && !Activator.getDefault().getResourceManager()
 148                                 .isAnyResourceExist() && collectionResourceBasicDetailsPage
 149                             .isSelectionDone())
 150                 || curPage == addResourcesToCollectionPage
 151                 || curPage == simpleResourceAddAttributePage
 152                 || (curPage == loadRamlPage && loadRamlPage.isSelectionDone() && loadRamlPage
 153                         .isMultiResourceCreation()) || curPage == devicePage) {
 154             return true;
 155         }
 156         return false;
 157     }
 158
 159     @Override
 160     public boolean performFinish() {
 161         System.out.println("performFinish()");
 162         final IWizardPage curPage = this.getContainer().getCurrentPage();
 163         System.out.println(curPage.getClass().getSimpleName());
 164         if (curPage == simpleResourceAddAttributePage) { // Handling Simple
 165             // Resource Creation
 166             // without RAML
 167             try {
 168                 getContainer().run(true, true, new IRunnableWithProgress() {
 169
 170                     @Override
 171                     public void run(IProgressMonitor monitor)
 172                             throws InvocationTargetException,
 173                             InterruptedException {
 174                         try {
 175                             monitor.beginTask(
 176                                     "Single Resource Creation Without RAML", 2);
 177                             monitor.worked(1);
 178                             createSingleResourceWithoutRAML();
 179                             monitor.worked(1);
 180                         } finally {
 181                             monitor.done();
 182                         }
 183                     }
 184                 });
 185             } catch (InvocationTargetException e) {
 186                 Activator.getDefault().getLogManager()
 187                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 188                 e.printStackTrace();
 189             } catch (InterruptedException e) {
 190                 Activator.getDefault().getLogManager()
 191                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 192                 e.printStackTrace();
 193             }
 194         } else if (curPage == loadRamlPage) { // Handling multi-instance
 195             // creation of simple resource
 196             // with RAML
 197             try {
 198                 getContainer().run(true, true, new IRunnableWithProgress() {
 199
 200                     @Override
 201                     public void run(IProgressMonitor monitor)
 202                             throws InvocationTargetException,
 203                             InterruptedException {
 204                         try {
 205                             monitor.beginTask(
 206                                     "Single Resource Creation(multi-instance) With RAML",
 207                                     3);
 208                             monitor.worked(1);
 209                             createMultiInstanceSingleResourceWithoutRAML();
 210                             monitor.worked(2);
 211                         } finally {
 212                             monitor.done();
 213                         }
 214                     }
 215                 });
 216             } catch (InvocationTargetException e) {
 217                 Activator.getDefault().getLogManager()
 218                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 219                 e.printStackTrace();
 220             } catch (InterruptedException e) {
 221                 Activator.getDefault().getLogManager()
 222                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 223                 e.printStackTrace();
 224             }
 225         } else if (curPage == updatePropPage) { // Handling the single instance
 226             // creation of simple resource
 227             // with RAML
 228             // String resURI = updatePropPage.getResURI();
 229             // Checking whether the uri is used by any other resource.
 230             if (Activator.getDefault().getResourceManager()
 231                     .isResourceExist(updatePropPage.getResURI())) {
 232                 MessageDialog
 233                         .openError(getShell(), "Resource URI in use",
 234                                 "Entered resource URI is in use. Please try a different one.");
 235                 // TODO: Instead of MessageDialog, errors may be shown on wizard
 236                 // itself.
 237                 return false;
 238             }
 239             // Resource resource = loadRamlPage.getResource();
 240             // resource.setResourceName(updatePropPage.getResName());
 241             try {
 242                 getContainer().run(true, true, new IRunnableWithProgress() {
 243
 244                     @Override
 245                     public void run(IProgressMonitor monitor)
 246                             throws InvocationTargetException,
 247                             InterruptedException {
 248                         try {
 249                             monitor.beginTask("Completing Resource Creation", 2);
 250                             monitor.worked(1);
 251                             completeResourceCreationWithRAML();
 252                             monitor.worked(1);
 253                         } finally {
 254                             monitor.done();
 255                         }
 256                     }
 257                 });
 258             } catch (InvocationTargetException e) {
 259                 Activator.getDefault().getLogManager()
 260                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 261                 e.printStackTrace();
 262             } catch (InterruptedException e) {
 263                 Activator.getDefault().getLogManager()
 264                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 265                 e.printStackTrace();
 266             }
 267         } else if (curPage == collectionResourceBasicDetailsPage
 268                 || curPage == addResourcesToCollectionPage) { // Handling
 269             // Collection
 270             // Resource
 271             // Creation
 272             // without RAML
 273             if (mainPage.getResourceOption() == ResourceOption.COLLECTION_FROM_RAML) {
 274                 Resource res = loadRamlPage.getResource();
 275                 if (null != res && res instanceof CollectionResource) {
 276                     Set<Resource> selectedResources = addResourcesToCollectionPage
 277                             .getSelectedResourceList();
 278                     if (!selectedResources.isEmpty()) {
 279                         int addedCount = Activator
 280                                 .getDefault()
 281                                 .getResourceManager()
 282                                 .addResourceToCollection(
 283                                         (CollectionResource) res,
 284                                         selectedResources);
 285                         if (addedCount > 0) {
 286
 287                             status = "[" + addedCount + "/"
 288                                     + selectedResources.size()
 289                                     + "] resources added to the collection";
 290
 291                             UiListenerHandler.getInstance()
 292                                     .resourceListUpdateUINotification(
 293                                             ResourceType.COLLECTION);
 294                         } else {
 295                             status = "Failed to add resources to the collection";
 296                         }
 297                     }
 298                 }
 299             } else {
 300                 // Checking whether the uri is used by any other resource.
 301                 if (Activator
 302                         .getDefault()
 303                         .getResourceManager()
 304                         .isResourceExist(
 305                                 collectionResourceBasicDetailsPage.getResURI())) {
 306                     MessageDialog
 307                             .openError(getShell(), "Resource URI in use",
 308                                     "Entered resource URI is in use. Please try a different one.");
 309                     // TODO: Instead of MessageDialog, errors may be shown on
 310                     // wizard
 311                     // itself.
 312                     return false;
 313                 }
 314                 try {
 315                     getContainer().run(true, true, new IRunnableWithProgress() {
 316
 317                         @Override
 318                         public void run(IProgressMonitor monitor)
 319                                 throws InvocationTargetException,
 320                                 InterruptedException {
 321                             try {
 322                                 monitor.beginTask(
 323                                         "Collection Resource Creation Without RAML",
 324                                         3);
 325                                 monitor.worked(1);
 326                                 createCollectionResourceWithoutRAML((curPage == addResourcesToCollectionPage) ? true
 327                                         : false);
 328                                 monitor.worked(1);
 329                                 if (curPage == addResourcesToCollectionPage) {
 330                                     UiListenerHandler.getInstance()
 331                                             .resourceListUpdateUINotification(
 332                                                     ResourceType.COLLECTION);
 333                                 }
 334                                 monitor.worked(1);
 335                             } finally {
 336                                 monitor.done();
 337                             }
 338                         }
 339                     });
 340                 } catch (InvocationTargetException e) {
 341                     Activator
 342                             .getDefault()
 343                             .getLogManager()
 344                             .log(Level.ERROR.ordinal(), new Date(),
 345                                     e.getMessage());
 346                     e.printStackTrace();
 347                 } catch (InterruptedException e) {
 348                     Activator
 349                             .getDefault()
 350                             .getLogManager()
 351                             .log(Level.ERROR.ordinal(), new Date(),
 352                                     e.getMessage());
 353                     e.printStackTrace();
 354                 }
 355             }
 356         } else if (curPage == devicePage) {
 357             final String devName = devicePage.getDeviceName();
 358             final Set<Resource> resourceList = devicePage
 359                     .getSelectedResourceList();
 360             try {
 361                 getContainer().run(true, true, new IRunnableWithProgress() {
 362
 363                     @Override
 364                     public void run(IProgressMonitor monitor)
 365                             throws InvocationTargetException,
 366                             InterruptedException {
 367                         try {
 368                             monitor.beginTask("Device Creation", 3);
 369                             monitor.worked(1);
 370                             createDevice(devName, resourceList);
 371                             monitor.worked(1);
 372                             UiListenerHandler.getInstance()
 373                                     .resourceListUpdateUINotification(
 374                                             ResourceType.DEVICE);
 375                             status = "Device Created.";
 376                             monitor.worked(1);
 377                         } finally {
 378                             monitor.done();
 379                         }
 380                     }
 381                 });
 382             } catch (InvocationTargetException e) {
 383                 Activator.getDefault().getLogManager()
 384                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 385                 e.printStackTrace();
 386             } catch (InterruptedException e) {
 387                 Activator.getDefault().getLogManager()
 388                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 389                 e.printStackTrace();
 390             }
 391         }
 392         return true;
 393     }
 394
 395     public MainPage getMainPage() {
 396         return mainPage;
 397     }
 398
 399     public SimpleResourceBasicDetailsPage getSimpleResourceBasicDetailsPage() {
 400         return simpleResourceBasicDetailsPage;
 401     }
 402
 403     public SimpleResourceAddAttributePage getSimpleResourceAddAttributePage() {
 404         return simpleResourceAddAttributePage;
 405     }
 406
 407     public CollectionResourceBasicDetailsPage getCollectionResourceBasicDetailsPage() {
 408         return collectionResourceBasicDetailsPage;
 409     }
 410
 411     public SimpleResourceOtherDetailsPage getSimpleResourceOtherDetailsPage() {
 412         return simpleResourceOtherDetailsPage;
 413     }
 414
 415     public AddResourcesToCollectionPage getAddResourcesToCollectionPage() {
 416         return addResourcesToCollectionPage;
 417     }
 418
 419     public LoadRamlPage getLoadRamlPage() {
 420         return loadRamlPage;
 421     }
 422
 423     public UpdatePropertiesPage getUpdatePropPage() {
 424         return updatePropPage;
 425     }
 426
 427     public DevicePage getDevicePage() {
 428         return devicePage;
 429     }
 430
 431     public StartStopResourcePage getStartStopPage() {
 432         return startStopPage;
 433     }
 434
 435     /*
 436      * public SingleResource getSimResource() { return simResource; }
 437      *
 438      * public void setSimResource(SingleResource simResource) { this.simResource
 439      * = simResource; }
 440      */
 441
 442     public void setStatus(String status) {
 443         this.status = status;
 444     }
 445
 446     public String getStatus() {
 447         return status;
 448     }
 449
 450     /*
 451      * public SingleResource getCreatedResource() { return simResource; }
 452      */
 453
 454     private void createSingleResourceWithoutRAML() {
 455         SingleResource resource = new SingleResource();
 456         // Basic resource details
 457         resource.setResourceURI(simpleResourceBasicDetailsPage.getResURI());
 458         resource.setResourceName(simpleResourceBasicDetailsPage.getResName());
 459         resource.setResourceTypes(simpleResourceBasicDetailsPage.getResTypes());
 460         resource.setObservable(simpleResourceBasicDetailsPage.isObservable());
 461         // resource.setStarted(simpleResourceBasicDetailsPage.isStart());
 462
 463         // Resource Attributes
 464         Map<String, LocalResourceAttribute> attributes = new HashMap<String, LocalResourceAttribute>();
 465         Set<AttributeHelper> attributeSet = simpleResourceAddAttributePage
 466                 .getAttributes();
 467         if (null != attributeSet && !attributeSet.isEmpty()) {
 468             Iterator<AttributeHelper> itr = attributeSet.iterator();
 469             AttributeHelper attHelper;
 470             LocalResourceAttribute localResAtt;
 471             // List<String> attValues;
 472             while (itr.hasNext()) {
 473                 attHelper = itr.next();
 474                 if (null != attHelper) {
 475                     localResAtt = attHelper.convertToLocalResourceAttribute();
 476
 477                     // Set the attribute value list.
 478                     /*
 479                      * attValues =
 480                      * Activator.getDefault().getResourceManager().getValueList
 481                      * (localResAtt); localResAtt.setAttValues(attValues);
 482                      */
 483                     attributes.put(
 484                             localResAtt.getResourceAttributeRef().name(),
 485                             localResAtt);
 486                 }
 487             }
 488             resource.setResourceAttributes(attributes);
 489         }
 490
 491         // Request types
 492         resource.setGetAllowed(simpleResourceOtherDetailsPage.isGetChecked());
 493         resource.setPutAllowed(simpleResourceOtherDetailsPage.isPutChecked());
 494         resource.setPostAllowed(simpleResourceOtherDetailsPage.isPostChecked());
 495
 496         // Call method of ResourceManager and update the response in the status
 497         // string.
 498         try {
 499             boolean result = Activator.getDefault().getResourceManager()
 500                     .createSingleResource(resource);
 501             if (result) {
 502                 status = "Resource created.";
 503                 resource.printResourceInfo();
 504             } else {
 505                 status = "Failed to create resource.";
 506             }
 507         } catch (SimulatorException e) {
 508             status = "Failed to create resource.\n"
 509                     + Utility.getSimulatorErrorString(e, null);
 510         }
 511     }
 512
 513     private void completeResourceCreationWithRAML() {
 514         try {
 515             boolean result;
 516             Resource res = loadRamlPage.getResource();
 517             if (res instanceof SingleResource) {
 518                 result = Activator
 519                         .getDefault()
 520                         .getResourceManager()
 521                         .completeSingleResourceCreationByRAML(res,
 522                                 updatePropPage.getResURI(),
 523                                 updatePropPage.getResName(), false);
 524             } else {
 525                 result = Activator
 526                         .getDefault()
 527                         .getResourceManager()
 528                         .completeCollectionResourceCreationByRAML(res,
 529                                 updatePropPage.getResURI(),
 530                                 updatePropPage.getResName());
 531             }
 532
 533             if (result) {
 534                 status = "Resource created.";
 535                 loadRamlPage.getResource().printResourceInfo();
 536             } else {
 537                 status = "Failed to create resource.";
 538             }
 539         } catch (SimulatorException e) {
 540             status = "Failed to create resource.\n"
 541                     + Utility.getSimulatorErrorString(e, null);
 542         }
 543     }
 544
 545     private void createMultiInstanceSingleResourceWithoutRAML() {
 546         try {
 547             int toCreateCount = loadRamlPage.getResourceCount();
 548             int resCreatedCount = Activator
 549                     .getDefault()
 550                     .getResourceManager()
 551                     .createSingleResourceMultiInstances(
 552                             loadRamlPage.getConfigFilePath(), toCreateCount);
 553             if (resCreatedCount > 0) {
 554                 status = "[" + resCreatedCount + " out of " + toCreateCount
 555                         + "]";
 556                 status += ((resCreatedCount == 1) ? "resource" : "resources")
 557                         + " created successfully.";
 558             } else {
 559                 status = "Failed to create resources.";
 560             }
 561         } catch (SimulatorException e) {
 562             status = "Failed to create resource.\n"
 563                     + Utility.getSimulatorErrorString(e, null);
 564         }
 565     }
 566
 567     private void createCollectionResourceWithoutRAML(boolean childResExist) {
 568         CollectionResource resource = new CollectionResource();
 569         // Basic resource details
 570         resource.setResourceURI(collectionResourceBasicDetailsPage.getResURI());
 571         resource.setResourceName(collectionResourceBasicDetailsPage
 572                 .getResName());
 573         resource.setResourceTypes(collectionResourceBasicDetailsPage
 574                 .getResTypes());
 575         resource.setObservable(collectionResourceBasicDetailsPage
 576                 .isObservable());
 577         // resource.setStarted(simpleResourceBasicDetailsPage.isStart());
 578
 579         // Call method of ResourceManager and update the response in the status
 580         // string.
 581         try {
 582             boolean result = Activator.getDefault().getResourceManager()
 583                     .createCollectionResource(resource);
 584             if (result) {
 585                 status = "Resource created.";
 586                 // Adding child resources.
 587                 if (childResExist) {
 588                     Set<Resource> selectedResources = addResourcesToCollectionPage
 589                             .getSelectedResourceList();
 590                     if (!selectedResources.isEmpty()) {
 591                         int addedCount = Activator
 592                                 .getDefault()
 593                                 .getResourceManager()
 594                                 .addResourceToCollection(resource,
 595                                         selectedResources);
 596                         if (addedCount > 0) {
 597                             status = "[" + addedCount + "/"
 598                                     + selectedResources.size()
 599                                     + "] resources added to the collection";
 600                         } else {
 601                             status = "Failed to add resources to the collection.";
 602                         }
 603                     }
 604                 }
 605             } else {
 606                 status = "Failed to create resource.";
 607             }
 608         } catch (SimulatorException e) {
 609             status = "Failed to create resource.\n"
 610                     + Utility.getSimulatorErrorString(e, null);
 611         }
 612     }
 613
 614     private void createDevice(String deviceName, Set<Resource> childs) {
 615         Activator.getDefault().getResourceManager()
 616                 .createDevice(deviceName, childs);
 617     }
 618
 619 }