Hi,

Recently I met with some of our current customers to talk about what is working, what isn't, and what could be improved in the Supportal. This post outlines the major hit items, as well as shows a list of the smaller features that are being considered for future versions of the Supportal. Thanks to everyone who helped, and I would appreciate any feedback / ideas on the items that are outlined below. If you haven't checked out the most recent feature, Issue Tracking, please do so as well.

Thanks and enjoy!

Top Requested

The top requested features / improvements were escalation, customer dashboard, and improved case filtering / sorting. To address these in more detail:

Escalation Process

Currently there is not a Supportal functionality that lets a customer alert Jive that an issue is in need of additional immediate attention.  You can create a Sev 1 issue (which does get our attention) but after this, if the case is long running or if it was not created as a Sev 1 initially, you need to call the Support line directly.  Other avenues are not as effective since they are not directly to Support: contacting an account manager is still an extra step, and bumping a thread with a new reply does not notify Support of any status change.  Building an escalation process into the Supportal is what we intend to do, and it will likely be as simple as your clicking "Escalate this" and providing an explanation.  That message would be sent to your account manager as well as the Support manager.

Customer Dashboard

Metrics can be very powerful within a support portal, especially when they are related to the health of your site and your interaction with technical support.  One frequently-requested feature is a roll-up displaying the past month's cases, including number of Sev 1s, top case reason, top case submitter, average response time, average resolution time, and many more.  Viewing this information on a weekly, monthly, quarterly, and lifetime basis would be ideal, and we'll see what we can do!

Improving case filtering / sorting

You need to find the cases that you are interested in, and right now that is a difficult task when you want anything more than just the open cases. The cases tab has just scratched the surface with filtering (current options are only "closed," "waiting on customer," "waiting on Jive," and "all'") and we fully intend to add additional filters like "my cases" and "only open" but also include advanced sorting. Many of you requested sorting on all columns of your support space, and that seems like a very valid request and is something we are aiming to do.

Second in line

The secondary issues included exposing case reasons and improving our issue-tracking integration. Case reasons are tracked internally, but exposing these will allow us to report them on the customer dashboard to answer questions like "How many bugs have we ran into in the past month?" or "How many customizations questions have we been asking lately?"  And after the initial issue tracking integration, we would like to have cases be updated automatically when the issue assigned to them has been closed.

Other ideas

Next up is a list of one-off features that will be evaluated and implemented in the future.

1. Change the UI for pointing a customer back to their account space from a public case. Perhaps adjacent to the normal breadcrumbs.
2. Make public cases visibly different in case listings.
3. No survey on every case.  Idea: for all level 1s, every other for level 2s, every 3rd for level 3s.
   1. If open / closed on same day, no need for survey.
4. Add a way to link cases that are related, which will help the support engineers.
5. Chat option for Sev 1 cases only (quick interaction without the phone).
6. We need to improve the navigation between jivesoftware.com and Jivespace / Supportal
7. Helpful to see the author of the post in the Open Cases widget. Rather author than case # (perhaps avatar too).
8. Sort the Open Cases widget by status for each of the Severity levels.
9. Export cases tab to Excel.
10. A 'read only' privileged group for cases (to be used for groups like managers)
11. Opening a case on behalf of someone else, which would include subscribing hime/her to watch notices for that case.
12. Want dates on cases (where it makes sense), either for a bug fix, or a restart, code push, etc.
13. If a member of more than one account space, have links at the top of current account space pointing to the other ones.

Out with the old

In the past, when a customer wanted to check on the status of any of their open cases they would log into their secure space overview page and use the Community Open Cases widget. This widget was designed with a very simple goal in mind, just display the open cases with a bit of extra information and an emphasis on Severity 1 issues. This proved useful for quite some time and gave customers a good overview of what was going on with their community from a support perspective.

However, there was one major flaw. Customers had no way of interacting with this information and often found it very difficult to organize this data in a manner that they could use quickly and efficiently. Welcome, open cases widget 2.0!

The new and improved open cases widget

Along with our upgrade of the Supportal to SBS 3.0, I took on the job of updating this widget to provide customers with better control over their open cases. There are two major upgrades that I gave this widget which have enhanced the way people use it:

1. Cases broken down by Severity

Instead of displaying all the open cases in a potentially enormous group, I've broken down the display into 3 distinctive parts. This is especially helpful for customers with more than 10+ open support cases at a time and allows customers to quickly see if they have any Level 1 issues that they need to attend to quickly.

2. New case option available: Priority

To the right of every case status is a set of up and down buttons which control the individual priority of every issue (within their respective severity).

Okay great, so how do I use it?

Step 1: Log in

Log into the Supportal and visit your Company's secure space "Overview" tab

Step 2: Organize open cases

Browse through any open cases and use the "move up/move down" buttons to re-order them. All the moving on the screen will be done in real-time thanks to our good old friend Javascript. You may recognize these buttons from SBS, as they are used to control the location of profile fields on the admin console registration settings page.

Step 3: Don't forget to Save!

As of right now, your cases will be in the order you want on the overview page, but there is one final step. You will need to click the Save Settings button at the bottom right hand corner of the widget. This will take the current ordering of your widget and persist the case priorities to the database.

You will receive a friendly notification at the top of the widget that your Priority changes have been successfully saved, and you are done!

Well that's easy enough, how does it all work?

I'm glad you asked--it's really quite simple.

Displaying the widget

First off, the widget loads up all the non-closed cases within a secure space and puts them into three different Collections (one for each severity):

for (String caseID : caseIDs) {
    try {
        SupportCase supportCase = supportCaseManager.getSupportCase(Long.parseLong(caseID));
        String status = supportCase.getStatus();
        if (status != null && !caseStatusManager.isClosedStatus(status)) {
            String severity = supportCase.getSeverity();
            String priority = supportCase.getPriority();
            supportCase.setPriority(priority != null ? priority : "0");
 
            if(severity.equals("Level 1")) {
                openSev1Cases.add(supportCase);
                Collections.sort(openSev1Cases, new CaseComparator());
            }
            else if(severity.equals("Level 2")) {
                openSev2Cases.add(supportCase);
                Collections.sort(openSev2Cases, new CaseComparator());
            }
            else {
                openSev3Cases.add(supportCase);
                Collections.sort(openSev3Cases, new CaseComparator());
            }
        }
    }
    catch (NotFoundException e) {
        log.error("Could not retreive support case in OpenCasesWidget: " + e.getMessage());
    }
}

(Ideally this will get refactored soon to allow for more or less than 3 severities instead of being hard-coded. But it will work for now.)

The CaseComparator() orders all the currently open cases by their priority in the database. If nothing has yet been set, it will be put in the order that the cases were created.

The fancy effects

The cases are now sent to the template, where they are displayed in their respective severity grouping and automatically hooked into the Javascript functions that allow the up/down buttons to work. When you click on one of the buttons the following Javascript magic happens:

1. References to the required objects on the screen are loaded up using Javascript:

var moveUp = function(e, type) {
    Event.stop(e);
    var ansc = this.up(".case-field");
    if(ansc != undefined) {
        ansc.previous().insert({before: ansc});
        updateHiddenField(ansc, ansc.next());
    }
    updateOrderingAnchors(type);
}

2. A hidden priority field for each case is updated with the new ordering value:

var updateHiddenField = function(element, newElement) {
    var temp = element.select(".case-priority")[0].value;
    element.select(".case-priority")[0].value = newElement.select(".case-priority")[0].value;
    newElement.select(".case-priority")[0].value = temp;
}

3. The ordering of the case above (or below if the down arrow was pressed) will be swapped on screen and the list rebuilt:

var updateOrderingAnchors = function(type) {
    if(type == "1") {
        var elms = $("sev1-case-list-body").select("tr");
    }else if(type == "2") {
        var elms = $("sev2-case-list-body").select("tr");
    }else{
        var elms = $("sev3-case-list-body").select("tr");
    }
    elms.each(function(tr, i) {
        var anchors = tr.select(".field-moveup")[0];
        if (i <= 0) {
            anchors.update("<span class='move-up-disabled'>move up</span>");
        }
        else {
            anchors.update(new Element("a", {"class": "anchor-move-up", href: "#"}).update("move up"));
        }
        anchors = tr.select(".field-movedown")[0];
        if (i == elms.length - 1) {
            anchors.update("<span class='move-down-disabled'>move down</span>");
        }
        else {
            anchors.update(new Element("a", {"class": "anchor-move-down", href: "#"}).update("move down"));
        }
    });
    bindAnchors();
}

4. Now that the ordering is complete, you click the Save Settings button which makes a call to this Javascript to call a DWR method and display the nice notification at the top of the widget:

CasePriorityAction.setPriorities( values, {
    callback:function() {
        $('save-button').enable();
        $('jive-success-box').style.display = "block";
        Effect.Fade($('jive-success-box'),{delay: 3, duration: 5});
    }
});

Saving the data

The final step involves saving this to the database, which is done by the call to the setPriorities DWR method as noted above. This loops through all the cases on the screen and sets the priorities in the database accordingly:

public void setPriorities(List<String> values) {
    try {
        for(String value : values){
            String[] vars = value.split("-");
            SupportCase supportCase = supportCaseManager.getSupportCase(Long.parseLong(vars[1]));
            supportCase.setPriority(vars[2]);
            
            supportCaseManager.updateSupportCase(supportCase);
        }
    }
    catch (NotFoundException e) {
        log.error("Could not retreive case in CasePriorityAction: " + e.getMessage());
    }
}

I hope this information provides you with interesting insight into how our custom development allows us to work smarter and more efficiently with all our customers.  We want these new features to enrich your Jive experience!

As always, Jive welcomes any and all feedback about this feature and the Supportal in general.  Please comment on this post or start a discussion in our Supportal Feedback space.

Welcome to Jive SBS! We just upgraded our Jivespace community to SBS 3.0.1, and along with it upgraded the Supportal customization, adding a few new features and improvements.

If you see any issues, please post a discussion in our Supportal Feedback space or create a public case there, and we'll get it addressed quickly.

Now, on to the new features:

An updated Open Cases widget allows prioritizing by the customer

We previously allowed you to view your open cases, but sometimes when you have a few open cases it can be helpful to rank them in importance--both for you and your company, but for us as well. Have a look at it here, and it will automatically be in your account's secure space next time you log in!

Account Member Management falls into the hands of the Customer

Prior to this Supportal upgrade, if you wanted to add or remove someone from your secure space, you needed to ask Support to do so. Well, with the upgraded Supportal, you can now put this power into the hands of someone that is currently a part of your account. There is still one manual step, asking Support to appoint one of your users as 'user admin' for your account. Once designated, the user admin can add and remove users, as well as add/remove the admin privilege should that assignment need to change. You can see the link to manage account members on the Group Membership Widget on your secure space overview. Don't see it? Ask Support to add it to your account space today!

First integrated Environment tracking on cases

Are you tired of Support continually asking what version you're running, or similar questions? Well, we're tired of asking it too ! We've now taken the first step to associating Environments to each and every one of your cases. That way, if the version does matter, we can simply take a look at the environment you have associated with the case and dive right into troubleshooting. What's the catch? We are going to need you to keep these as current as possible in order to make this all work smoothly. We are hoping to evolve this to be able to eliminate the Product drop down and solely use Environments in the future. We welcome your feedback and help in shaping this new feature in the Supportal. Please visit our Supportal Feedback space to do this.

Lastly, some new UI when creating a case

As you can see from the screenshot above, we've added some indication of what fields are required when creating a new case, and something you may also not notice is that we have taken away the 'Stage' detail as it was not useful to us.

Again, please let us know if you see any issues, and we hope you enjoy the new Supportal and the overall upgrade to SBS!

Last episode I explained how we create the secure spaces and setup permissions (see How do the account spaces get created anyway? Is it private?). This post deals with the default widgets that come with a newly created community, and how we had to customize this functionality to meet our requirements.

I. How it's done out of the box

To do this, let's first take a look at how it would be done out of the box:

1. Create a new community
2. Then get re-directed to the newly created community

          Here, community.ftl will call CommunityAction's getWidgetLayout via:

<#if widgetLayout?exists>
    <div id="jive-body-main">
        <div id="jive-widget-content">
            <div id="thread.watch.notify" class="jive-info-box" style="display:none">
            </div>

            <#include "/template/global/include/form-message.ftl" />

            <#include "${widgetLayout.freemarkerTemplate}" />

        </div>
    </div>
</#if>

And within getWidgetLayout() you'll see that if we haven't customized a community and a layout doesn't exist yet, we'll just copy the default:

public WidgetLayout getWidgetLayout() {
        try {
            if (!isHasCustomized()) {
                // if no draft widget frames exist, then no default layout exists
                if (widgetManager.getWidgetFrames(getCommunity()).size() == 0) {
                    copyDefaultLayout();
                }
                .....

And to copy the default, we do this:

/**
* Copy the default layout (large left, small right) to the current community.
*/
     protected void copyDefaultLayout() {
          WidgetManager widgetManagerUnproxied = (widgetManager instanceof WidgetManagerProxy) ? ((WidgetManagerProxy)widgetManager).getUnproxiedObject() : widgetManager;
 
          try {
               WidgetLayoutDescriptor wld = widgetManagerUnproxied.getWidgetLayoutByName(TwoColumnLargeLeftColumnLayout.class.getName());
               WidgetLayout wl = widgetManagerUnproxied.getWidgetLayout(wld);
               widgetManagerUnproxied.addWidgetLayout(getCommunity(), wl);
          .....             

And at that point, you'll have the default layout with no widgets, and so further down the line you'll see a call to getWidgetFrames, and similarly to above it will copy the default:

public Map<Integer, List<WidgetFrame>> getWidgetFrames() {
        if (!isHasCustomized()) {
            if (widgetManager.getWidgetFrames(getCommunity()).size() == 0) {
                copyDefaultFrames();
            }
          .....

which will add the default widgets:

/**
     * Copy the default widget frames to the current community:
     *  <ul>
     *      <li>Left: Sub-Spaces</li>
     *      <li>Left: Projects</li>
     *      <li>Left: Recent Activity</li>
     *      <li>Right: Actions</li>
     *      <li>Right: Top Members</li>
     *      <li>Right: Tag Cloud</li>
     *  </ul>
     */
    protected void copyDefaultFrames() {
        try {
            WidgetManager widgetManagerUnproxied = (widgetManager instanceof WidgetManagerProxy) ? ((WidgetManagerProxy)widgetManager).getUnproxiedObject() : widgetManager;
 
            // column 1
            int row = 0;
            if (widgetManagerUnproxied.getWidgetByName(SubCommunitiesWidget.class.getName()) != null) {
                widgetManagerUnproxied.addWidgetFrame(WidgetUtils.createWidgetFrameBean(getCommunity(), SubCommunitiesWidget.class.getName(), 1, row++));
            }
            if (isProjectsEnabled()) {
                if (widgetManagerUnproxied.getWidgetByName(CommunityProjectsWidget.class.getName()) != null) {
                    widgetManagerUnproxied.addWidgetFrame(WidgetUtils.createWidgetFrameBean(getCommunity(), CommunityProjectsWidget.class.getName(), 1, row++));
                }
            }
            if (widgetManagerUnproxied.getWidgetByName(RecentContentWidget.class.getName()) != null) {
                widgetManagerUnproxied.addWidgetFrame(WidgetUtils.createWidgetFrameBean(getCommunity(), RecentContentWidget.class.getName(), 1, row));
            }
 
            // column 2, start row back at 0
            row = 0;
            if (widgetManagerUnproxied.getWidgetByName(CommunityActionsWidget.class.getName()) != null) {
                widgetManagerUnproxied.addWidgetFrame(WidgetUtils.createWidgetFrameBean(getCommunity(), CommunityActionsWidget.class.getName(), 2, row++));
            }
            if (widgetManagerUnproxied.getWidgetByName(TopMembersWidget.class.getName()) != null) {
                widgetManagerUnproxied.addWidgetFrame(WidgetUtils.createWidgetFrameBean(getCommunity(), TopMembersWidget.class.getName(), 2, row++));
            }
            if (widgetManagerUnproxied.getWidgetByName(TagCloudWidget.class.getName()) != null) {
                widgetManagerUnproxied.addWidgetFrame(WidgetUtils.createWidgetFrameBean(getCommunity(), TagCloudWidget.class.getName(), 2, row));
            }
        }
        ......

II. How do the objects interact, and how are they displayed?

Sometimes these widget layouts, widget layout descriptors, widgets, widget frames, etc can get kind of confusing. I hope this illustration and ftl explanation can help paint a better picture, and deepen the understanding.

As an overview, you have the layout (red - WidgetLayout), the layout descriptor (blue - WidgetLayoutDescriptor) which tells how to display the widgets (green - WidgetFrames, contain widgets). A bit more technical tidbits from the database side of things, the container in jiveWidgetFrame is essentially the column, and the frameIndex is essentially the row. See more here:http://www.jivesoftware.com/builds/docs/clearspace/latest/DatabaseSchemaGuide.html#jiveWidgetFrame

We saw above how it will grab the widget layout, but I didn't show it returning from that method. This can be seen as the red box in the picture above (the layout)

<#if widgetLayout?exists>
    <div id="jive-body-main">
        <div id="jive-widget-content">
            <div id="thread.watch.notify" class="jive-info-box" style="display:none">
            </div>

            <#include "/template/global/include/form-message.ftl" />

            <#include "${widgetLayout.freemarkerTemplate}" />

        </div>
    </div>
</#if>

public WidgetLayout getWidgetLayout() {
        try {
            if (!isHasCustomized()) {
                // if no draft widget frames exist, then no default layout exists
                if (widgetManager.getWidgetFrames(getCommunity()).size() == 0) {
                    copyDefaultLayout();
                }
                return widgetManager.getWidgetLayout(getCommunity());

After returning the layout, we look to the layout FTL (which for this particular layout is ls.ftl) and CommunityAction for what happens next (this is the blue box above, the layout descriptor). Each different layout FTL asks for the widget frames associated with it, and will have them available via the CommunityAction. For our example, it looks for the widget frames in the left container, and then the right container.

This loads the widgets in the left container (green A)...

<div id="jive-body-layout-ls">
    <div class="jive-body-layout-l">
        <div id="jive-widget-container_1" class="jive-widget-container jive-widget-container-large">
         <#if widgetFrames?exists && widgetFrames.containsKey(1?int)>
             <#list widgetFrames.get(1?int) as widgetFrame>
                 <#if widgets?exists>
                     <@jive.editWidgetFrame widgetFrame=widgetFrame />
                 <#else>
                     <@jive.displayWidgetFrame widgetFrame=widgetFrame size=enums["com.jivesoftware.community.widget.Widget$ContainerSize"].LARGE />
                 </#if>
             </#list>
         </#if>
        </div>
    </div>

....and the rest of the file loads the widgets in the right container (green B)

    <div class="jive-body-layout-s">
         <div id="jive-widget-container_2" class="jive-widget-container jive-widget-container-small">
         <#if widgetFrames?exists && widgetFrames.containsKey(2?int)>
             <#list widgetFrames.get(2?int) as widgetFrame>
                 <#if widgets?exists>
                     <@jive.editWidgetFrame widgetFrame=widgetFrame />
                 <#else>
                     <@jive.displayWidgetFrame widgetFrame=widgetFrame size=enums["com.jivesoftware.community.widget.Widget$ContainerSize"].SMALL />
                 </#if>
             </#list>
         </#if>
         </div>
    </div>
</div>

They widgetFrames are available from this call to the widgetManager in CommunityAction.getWidgetFrames():

return widgetManager.getPublishedWidgetFrames(getCommunity());

And that's it! The widgets are displayed.

III. How we customized this

As you've seen, it's all initiated by NOT having anything setup the first time you are directed to the community.ftl file. So, we needed to ensure that there was a widget layout, and within that widget layout there are widget frames. So, during our secure space creation we need to hook into this ourselves. Have a look at how we're doing it:

1. Get a list of all the widgets in the system

Map<WidgetDescriptor, Widget> widgets = widgetManager.getAvailableWidgets();

2. Identify the two widgets we want to add initially, and loop through all the available widgets and hold onto them

Widget actionWidget = null;
Widget openCasesWidget = null;
for(Iterator<WidgetDescriptor> it = widgets.keySet().iterator(); it.hasNext(); ) {
     WidgetDescriptor descriptor = it.next();
     Widget widget = widgets.get(descriptor);
 
     if(descriptor.getClassName().equalsIgnoreCase("com.jivesoftware.community.widget.impl.CommunityActionsWidget")) {
          actionWidget = widget;
     } else if(descriptor.getClassName().equalsIgnoreCase("com.jivesoftware.community.portal.widgets.OpenCasesWidget")) {
          openCasesWidget = widget;
     }
}

3. Then, as we saw above, we need to get the widget layout desired and add it to the newly created secure community

try {
  WidgetLayoutDescriptor wld = getWidgetLayoutByName(TwoColumnLargeLeftColumnLayout.class.getName());
  WidgetLayout wl = widgetManager.getWidgetLayout(wld);
  widgetManager.addWidgetLayout(community, wl);
  widgetManager.publishWidgetLayout(community);
}

4. Finally, setup our OpenCasesWidget (custom built by us) and the Actions widget. They are mapped to the correct lay out by the matching up of parentObjectType and ParentObjectID.

//load the widgets
WidgetFrameBean widgetBean = new WidgetFrameBean();
widgetBean.setWidgetID(openCasesWidget.getID());
widgetBean.setContainerID(1);
widgetBean.setParentObjectID(community.getID());
widgetBean.setParentObjectType(JiveConstants.COMMUNITY);
widgetBean.setPublished(true);
widgetManager.addWidgetFrame(widgetBean);
 
WidgetFrameBean actionWidgetBean = new WidgetFrameBean();
actionWidgetBean.setWidgetID(actionWidget.getID());
actionWidgetBean.setContainerID(2);
actionWidgetBean.setParentObjectID(community.getID());
actionWidgetBean.setParentObjectType(JiveConstants.COMMUNITY);
actionWidgetBean.setPublished(true);
widgetManager.addWidgetFrame(actionWidgetBean);

5. All done!

That is how we are creating the communities and customizing their overview tabs. Hope this has been helpful!

Let me know if there are any questions on the above functionality

Hello Jivespace users,

For those of you who are customers and have been using Jive's support solution (the 'Supportal'), please read on to see what changes have happened recently and how they benefit you! I will also touch on what else may have changed and how it could impact your usage (plus how to take care of it!).

If you are not a customer yet, most of this information does not apply, but it does showcase the support solution that Jive has developed and is using.

Jivespace Updated, new version of the Supportal deployed

Jivespace was updated to 2.5.5, and the Supportal plugin, which recently went a 3.5 month development cycle, was deployed last Thursday, the 18th. It was a big upgrade for the Supportal as it went under the knife and was essentially re-engineered from the ground up. It is currently developed by our very own support engineers Scott Hirdes and myself.

New Features

You will no doubt notice a few changes, but just in case you don't see them all, here is a showcase of the new features which impact the customer directly:

1. Auto Close

Cases are now going to be automatically followed up on if they are idle for more than 5 business days. This can be turned off on a per-case basis by simply choosing 'No' on the case details 'Allow this case to be auto closed' option.

2. Public Case Navigation

Have you created a public case yet? If not, please read about it here: http://www.jivesoftware.com/jivespace/docs/DOC-2932 under the section Best Uses for "Allow Case to be Public." And if you have already created a public case, did you notice that it was difficult to get back to your account community after viewing your public case? Well not anymore! If you have created a public case, you can now navigate back to it with the link at the top of the case:

3. Moving towards Account Management

You now have a couple features which let us take the first steps into account management from the Supportal. Group Membership Widget & Support Status tab.

The Group Membership Widget can be added to your account community, and it will then show the contacts from your company who have access to your company's cases. You can ask any support engineer to add this widget to your account community!

The Support Status tab is a way for you to check if you currently have support with us. If there are any problems with this, please contact us!

Those are the new features that impact you as the customer, but there are many more changes to the plugin which benefit our support engineers, and the plugin as a whole!

Change which could affect your day to day usage

We fixed some issues with our account synchronization rules, to more appropriately reflect our underlying account information.  If you no longer see an account community that you believe you should have access to, please email accountsupport@jivesoftware.com.

If you see any other issues, please let me know as soon as you can!

Thanks and enjoy!

Customer Portal Launching!

On Monday, May 19th, we launched a new support solution to provide our customers with a better support experience.  We are moving from our old email based system, to leveraging our Jive Communities ClearspaceX instance to provide discussion based support via cases.  What does this mean for you?  Well there are a lot of high level benefits:

• No more losing emails in the internet--attachments are particularly bad at causing this

• You can now view all your cases with us, and check on the status

• You can choose to make cases private or public--knowing that we will respond to both regardless of who can see them.

There are some things to be aware of regarding the new processes:

What About my Existing Open Cases?

All emails sent into Jive will be created as new cases--this will be the primary point for the case moving forward, although we will ensure that your cases' history is maintained so that we do not lose any context when solving your issue.

Your "Personal" Community

When you log into Jive Community (this site), assuming you have an active support contract, and email address, you will now see a new community under the Support Community named after your company.  This is a community that only members of your company, and Jive can see.  Everything created in here is private.  If you are not seeing your Personal Community, please email accountsupport@jivesoftware.com.

Email

You can still send emails, and the system will automatically process and publish them online.  As long as you have an account with a valid email address, email will work just fine.  Additionally, assuming you have not disabled your watches, you will receive a watch update when we (or someone else if public) responds to your case.

Keeping Track of Cases

After logging in, just navigate to your personal space (your company name).  If you don't see it, email accountsupport@jivesoftware.com.  Within your space, you will see all your open cases on the overview tab, and a complete history of all your cases on the cases tab.  Please note, that due to the new solution, cases processed using the email system will not show up.

How Can my Co-Workers Submit Cases?

Assuming we have a record of your coworker (if not, just email accountsupport@jivesoftware.com), all your coworker needs to do is create an account on jivesoftware.com/community using their work email address, and then they will also see your personal company space.  Additionally, your co-worker will also see all your cases, their status, and can create cases themselves.

What are Private and Public Cases?

When you create a case, you have an option to make it public, and to select in which community you want to create the case.  The default however is private.  We have this set to protect your security, and to ensure that any public information is intentionally shared.  When a public case is created it shows up as a discussion in the community you chose.  Others can see and respond to your case just like a discussion--in fact they won't even know that it is a case!

When creating the case do not worry if you need to make it private later on.  You can make a case public or private at any point throughout the case's history.

Please give us your feedback and let us know what you think.  We are constantly striving to improve your experience with Jive Support!

How to set up/use your new space

The attached document contains step by step instructions with screenshots on how to access your private community.