}

   

    @SuppressWarnings("deprecation")

    public Widget publishWidgetUrlToWookie(String widgetStrUrl){

        File tempWgtFile = null;

        try {

            if(adminUsername.equals(null) || adminUsername.equals("") || adminPassword.equals(null) || adminPassword.equals("")){

                throw new WookieConnectorException("Either the wookie username or password is not defined in portal.properties", null);

            }

            connectorService = getWookieConnectorService(wookieServerUrl, wookieApiKey, "");

            // TODO - replace code with line below when bundled with wookie 0.13.0

            // wookie-0.13.0 can accept postWidget with a url parameter as well as file parameter

            //org.apache.wookie.connector.framework.Widget wookieWidget = connectorService.postWidget(widgetUrl, adminUsername, adminPassword);

           

            URL widgetUrl = new URL(widgetStrUrl);

            String tempUploadFolder = System.getProperty("java.io.tmpdir");

            String filename = normalizeFileName(widgetUrl);

            tempWgtFile = new File(tempUploadFolder, filename);

            FileUtils.copyURLToFile(widgetUrl, tempWgtFile, 10000, 10000);

            org.apache.wookie.connector.framework.Widget wookieWidget = connectorService.postWidget(tempWgtFile,  adminUsername, adminPassword);

            widget = new W3CWidget();

        } catch (WookieConnectorException e){

            logger.warn(e.getMessage());

            return returnURLFromConfig(tempWgtFile);

        } catch (MalformedURLException e) {

            logger.error("Malformed url error. " + e.getMessage());

    // so we can determine if it has already been added to rave without having to reimport to wookie.

    // This routine does not generate identifiers, as wookie would on empty <id> elements found in the config.xml.

    // NOTE: this has been fixed in wookie 0.13.0 onwards

    private Widget returnURLFromConfig(File wgtFile){

        try {

            final ZipFile zipFile = new ZipFile(wgtFile);

            ZipEntry entry = zipFile.getEntry("config.xml");

            InputStream input = zipFile.getInputStream(entry);

            BufferedReader br = new BufferedReader(new InputStreamReader(input, "UTF-8"));

            try {

                String line = null;

                while (( line = br.readLine()) != null){

                    if(line.contains("id=")){

                        String val = line.substring(line.indexOf("id=")+4, line.indexOf("\"", line.indexOf("id=")+5));

                        widget = new W3CWidget();

                        return widget;

                    }

                }

            }

            finally {

       

        expect(widgetService.getWidget(VALID_IDENTIFIER)).andReturn(TEST_WIDGET);

        replay(widgetService);

       

        assertNotNull(w);

    }

        replay(wookieWidgetMetadataRepository);

       

        expect(widgetService.getWidget(VALID_IDENTIFIER)).andReturn(null);

        replay(widgetService);

        assertNull(w);

    }

     * @param url url for the widget

     * @return

     */

    public Widget getMetadata(String url) {

        JSONObject jsonGadget = null;

        try {

            jsonGadget = (JSONObject) new JSONTokener(gadgetMetadataRepository.getGadgetMetadata(url)).nextValue();

            if (jsonGadget != null) {

                String query = jsonGadget.getString("modulePrefs");

                if (query != null) {

                    JSONObject jsonModulePrefsObject = (JSONObject) new JSONTokener(query).nextValue();

                    if (jsonModulePrefsObject != null) {

                    }

                }

            }

        } catch (JSONException e) {

            try {

    @Test

    public void getMetadata() {

        expect(gadgetMetadataRepository.getGadgetMetadata(VALID_GADGET_URL)).andReturn(VALID_METADATA);

        replay(gadgetMetadataRepository);

        assertNotNull(w);

    }

    @Test(expected = IllegalArgumentException.class)

    public void getMetadata_invalid() {

        expect(gadgetMetadataRepository.getGadgetMetadata(VALID_GADGET_URL)).andReturn(INVALID_METADATA);

        replay(gadgetMetadataRepository);

        assertNotNull(w);

    }

    }

    @Override

    public String getEncryptedSecurityToken(String pageId, String url) {

        Page page = pageService.getPage(pageId);

        validate(widget);

        // Use a dummy RegionWidget to generate the security token

        RegionWidget regionWidget = new RegionWidgetImpl(String.valueOf(System.currentTimeMillis()),"-1",

                new RegionImpl("-1", page, -1));

    }

    @Test

    public void getEncryptedSecurityToken_valid() {

        Page page = new PageImpl(VALID_PAGE_ID, VALID_OWNER_ID);

        expect(widgetService.getWidgetByUrl(VALID_GADGET_URL)).andReturn(widget);

        expect(pageService.getPage(VALID_PAGE_ID)).andReturn(page);

        expect(tokenService.getEncryptedSecurityToken(isA(RegionWidget.class), eq(widget))).andReturn(VALID_TOKEN);

        replay(widgetService, pageService, tokenService);

    }

    @Test(expected = IllegalStateException.class)

    public void getEncryptedSecurityToken_NotPublished() {

        expect(widgetService.getWidgetByUrl(VALID_GADGET_URL)).andReturn(widget);

        replay(widgetService, pageService, tokenService);

        assertThat(openSocialService.getEncryptedSecurityToken(VALID_PAGE_ID, VALID_GADGET_URL), is(equalTo(VALID_TOKEN)));

    }