SuperOffice CRM Professionals

Experienced experts in SuperOffice CRM - those primarily responsible for the setup, configuration, maintenance of SuperOffice in an organization, as well as those responsible for the implementation of applications or integrations, or provide consultancy services as to how an integration should be implemented using current industry standards.

Latest Forum Posts

  • David Hollegien

    Also tried this with the latest NuGet 10.1.2 packages now that they are out, same issue occurs.

    David Hollegien 05/24/2022
  • Tony Yates

    Hi David,  I registered this as a bug last week.  Best regards

    Tony Yates 05/23/2022
  • OU

    Hi, I've done a Search for Contact, if contact not exist = create contact in SuperOffice CRM. I use this ZAP to create a Contact from a Facebook Lead Form.  But, I can't manage to list the different roles from the Zapier integration, all other field fetch from API correct. Please help!

    Open User 05/20/2022
  • m

    Currently developing a script launched with the press of a bit of text in screen designer. I'd like to send the user to a specific URL that is found with the script.   I found the following in nseventdata: SetNavigateTo(String) I presume this is where I can set a URL to send the user off to, but nothing appears to happen upon setting it, so I must be missing something. Does anybody have any ideas on how to solve this?   Thank you MTO

    mto 05/18/2022
  • Erik Eide

    We are introducing a new feature called "configurable archives" that enable the posibility to add and remove archive on main screens. This means that you may remove the quote tab in the sales panel for all users or spesific groups of users.  This feature is ready for pilot in 10.1.3 as a pilot program, and requires Expander Services.

    Erik Eide 05/16/2022
  • Eivind Johan Fasting

    Figured out this is set the same way as on person:  NSImage image; image.SetImage(bytes); NSBLOBAgent blobAgent; blobAgent.SetProductImage(productId, image);

    Eivind Johan Fasting 05/13/2022
  • Andreas Bergstrand

    Hi Tony, Very interesting indeed. Do you know more about when you might stop supporting the WCF services completely in Online/Onprem? Are we talking sometime this year, or is it later on? //Andreas

    Andreas Bergstrand 05/11/2022
  • Tony Yates

    We are working on a new  REST based API for Quote Connectors in Online , which is an alternative to the WCF-based API we have today. Please take a look article and express any feedback or concerns you may have. 

    Tony Yates 05/10/2022
  • PB

    Hi Tony,   Thanks for the reply. Yes, I do think I was fooled by a caching issue. However to me it looked like a a restart of application pools was needed to bust the cache. Maybe I'm just impatient.  Thanks for helping Peter

    Peter Borg2 05/09/2022
  • David Hollegien

    Hi, You should use the ResourceAgent for this instead of trying to do it directly on the database. Sample for getting all active label replacements: #setLanguageLevel 3; NSResourceAgent resourceAgent; // empty = get all String[] resourceNames; // empty = get all String culture; foreach (NSResourceOverride resourceOverride in resourceAgent.GetResourceSubstitutions(resourceNames, culture, true)) { printLine( "[" + resourceOverride.GetCulture() + "] " + resourceOverride.GetResourceName() + " =>" + resourceOverride.GetResourceValue()); } The ResourceAgent also contains methods for updating the label replacements

    David Hollegien 05/06/2022
  • Christian Mogensen

    We are working on a new REST based API for Quote Connectors in Online . This would be an alternative to the WCF-based API we have today. Please take a look: 

    Christian Mogensen 05/04/2022
  • Martin Andersen

    Hi again! Now the dust has settled and everything is good!  But how do we handle that the browser window is closed before the login has been entered? Does anyone have a solution for that?  

    Martin Andersen 05/02/2022

Technical blog posts

Quote Connector REST API proposal

Take a moment to read the Quote Connector REST API proposal  

Christian Mogensen
thumb_up1 mode_comment0

The future of NetServer

SuperOffice delivers multiple products. Customers see the Sales and Service applications, Customer’s customers see things like Chat, Forms, and the customer-facing side of Service; and both Customers and Partners see our programming interfaces. Those interfaces exist in several different ways. At the least-technical end we have configuration and preferences – these are “interfaces” that require no programming, but can still influence what the application does to a considerable degree. Then we have CRMScript and Configurable Screens, where a combination of programming and configuration is used to change the application. If we step into the more technical programming domain, we come to the Web Service API of NetServer, consisting of the endpoints that are strictly defined in our service model. Building NetServer web services based on service-oriented/service-agent architecture allows us to overlay (or expose) our API in various standardized ways, such as SOAP, REST, OData, and potentially other protocols based on industry trends.  These API’s are mostly accessed from programs, requiring a developer to write the code that uses them to perform some task. Up to this point, Online and Onsite installations offer the same API functionality; and they do so in a way that hides the implementation details (as well as many database details) from the caller. On a more technical level, we distribute SDK packages with the actual NetServer code, such that any public class XYZ is available to call. This gives access to lower-level code, including the ability to perform queries and updates on any table; access business logic. We also provide the ability to add logic with plugins that extend or override our functionality. It’s also possible to load a script file or DLL that our service API layer calls before and after any service API request is executed. Parallel to that, it’s possible to supply XML files that extend or override the logic in our PageBuilder user-interface engine; typically, in connection with backend plugins that provide server-side logic. These ways of accessing our code are only available Onsite , and it’s these that are the subject of the rest of this article. The world is changing – in fact it never stopped NetServer was designed quite some time ago, and I’m proud of the job the whole team did back then. While the world has progressed from .NET 1.0 up to today, the basics of NetServer have stayed the same – so much that we are almost completely compatible with code written 10 years ago. This has benefitted both us and the partners, providing a stable platform for development. But while we have held still, the world has moved. Some fashions have come and gone, some have persisted, and new ones have arrived. Now the distance between the world we designed for and the world of today has become so large that we must move with it. I am of course referring to .NET 6, but not only that, or at least not just the direct consequences. When Microsoft started the .NET Core project, one of their really fundamental decisions was to break compatibility with the platform . This means a valid .NET 4.8 program may not compile or run in .NET 6; and it may force a non-trivial rewrite. Examples of this include: When we first implemented NetServer, Windows Communication Foundation was brand new (SuperOffice was among the companies that sent a delegation to Redmond to beta test it). In .NET 6 it does not exist. NetServer was designed with “ambient variables” that keep track of identity, database, configuration and threading – as was the best practice at the time. .NET 6 is built around dependency injection and thus explicit management of these things. NetServer has a thread manager that is very conscious of when threads are created, run and destroyed; and integrates this tightly with the ambient variables. .NET 6 is totally oriented to async/await where actual threads are incidental and it’s in practice impossible to replicate the current NetServer approach. We are now at the point where Microsoft has effectively put .NET 4.8 on life support. The latest versions of the C# language are not supported (see link ). The tool chains are dying, and if you complain the answer is more and more often “hey, why are you still on 4.8?”. Finally, the demands and idioms of modern testing are not compatible with the ambient variables and “implicitness” of NetServer. It was a good pattern for its time, but that time is behind us. ‘nuff said – we have known for some time that we need to move, and we have started to do so. Compatibility – where and when The most important point I wish to make here is this: Our API endpoints – the Agents and their methods – will stay the same. If you are already integrating with us by calling them via REST, you’re fine. Read the rest if you want, or just go do something else. If you are calling us via WCF, please prepare to stop doing that and switch to REST. We will help, and we will keep WCF for a while yet, but just like .NET 4.8, WCF should be considered a dead end now. If you have NetServer in-process and are calling or extending our code directly, it’s going to be worse. It’s clear that we need to make some drastic refactoring in our code. Switching from ambient variables to explicit dependency injection is going to touch just about every class (even if much of the actual object management is done through factories, service providers and dependency resolvers at runtime). The next onsite release of NetServer will contain the first block of these changes. Startup of NetServer will no longer be implicit/lazy, but will instead use the standard startup and composition patterns from .NET 6. We have made startup methods for various environments (WinForms/desktop; IIS web; win service; …) but it doesn’t happen by itself – in fact that’s the point of having an explicit startup. It means that all integrations that run NetServer in process will have to add Startup code, suitable for their environment. But it doesn’t stop there. It doesn’t make sense for us to just make the least possible amount of changes, because that would just incur the costs without reaping the gains. There are many things that can be done once we’re on .NET 6 – think about async/await; operation cancellation; better state and identity handling. All of these will need changes to public classes: for instance, to enable cancellation all the way to the database, cancellation tokens will make an appearance and that will be reflected in various internal api’s. On top of that, there are functional refactoring's that we wish to make. There’s stuff in the userpreference table that should be elsewhere; the visiblefor table can be scrapped; user-defined fields and extra_fields should become the same thing, i.e. custom fields . There's 100.000 lines of generated code for Row field-change events that are never used. I could go on but the idea should be clear: None of these changes will break the Service API; all of them will break some class compatibility and many will break low-level database compatibility. A dark future? As always, SuperOffice strives to satisfy all parties – customers, partners and ourselves. We actually believe in our own slogan, that relations matter; and we’re not going to make life difficult for anyone on purpose. However, we both want and need to move with the rest of the industry; we can’t let our ecosystem become obsolete in the name of compatibility. That would ultimately hurt everyone. We therefore need to manage this transition as well as we possibly can. Our customers are migrating to the Cloud and in a sense that solves it, because the low-level integrations that get broken by our changes don’t exist there. We take the compatibility on the API level extremely seriously and do not plan to break it. As far as possible, we will try to give reasonable warning times when we see that a breaking change is coming; and we will do our best to have help and advice available on how to tackle it. Any such changes break our own code too, so we definitely eat our own dog food and should therefore be able to present solutions. We’d also like to involve partners to better understand what kind of changes hurt and how much; and if there are particular things we can do, avoid or retime to lessen the pain. All that said… we’ve spent more than a year on preparatory work. Migrating our code management to the cloud; rebuilding tool chains; cleaning out all sorts of old spiders and bones from our code; investigating different technologies and alternatives. Now we’re at the point where the actual transitional work has started, and it will accelerate throughout this year. While the transition may be a trifle rough, I very much look forward to when we are done. In tandem with the evolution of our Online platform, our code will be better positioned than ever to work in a Cloud environment, carrying developers, partners and customers from one era of computing to another. It's definitely not going to be boring.   Dr. Marek Vokáč Chief Engineer, SuperOffice R&D

Marek Vokáč
thumb_up10 mode_comment0

The story of the monorepo

On June 23rd, 2021, we announced after consolidating content across two community clubs, six stand-alone static websites, and several blog and forum posts. Behind the scenes, the old content was organized in five GitHub repositories: superoffice-docs , database , data-access, crmscript , and user-interface . Now, we have taken the consolidation one step further and combined these five repos into one : superoffice-doc s. This giant refactoring benefits authors and contributors and paves the road for future improvements. The published site is more or less the same (changes listed later in this post). Why As we gained experience from working with content tasks on the new site, we noticed some overhead : Conceptual information for company, contact, diary, document, project, quote, request, and sale was scattered throughout the five repos. Common settings (cspell), templates, and reusable text chunks were duplicated in each repo. We had to manage dependencies between repos. If you moved or renamed a file in repo A, you also had to make changes in the other repos to avoid broken links - which meant multiple branches and pull requests that had to be coordinated. We lost Git history when we moved content from one repo to another. The backlog was fragmented. We had to create an umbrella project and board to track and prioritize all issues in one location. The tools and build pipeline had to be aware of all repos and juggle Git submodules. It also added complexity for those who wanted to build the whole site locally. In addition, it was not always clear where something belonged. Contributors got confused and had to look in multiple repos before finding stuff. Solution Essentially, we did a sophisticated Git merge for each repo using a tool called git filter-repo followed by clean-up. Grouped how-tos. Grouped all downloadable files. Got rid of most duplicates. Moved all whats-new pages to superoffice-docs/release-notes/. Updated all links. Updated table-of-contents files (toc.yml). Renamed and moved physical folders to match the output URLs. Created a new build file, which turned out to be a third of the old one.   The four main graft points are: crmscript to superoffice-docs/docs/automation/crmscript/ database to superoffice-docs/docs/database/ data-access to superoffice-docs/docs/api/ user-interface to superoffice-docs/docs/ui/ You can read all about the details in the monorepo GitHub issue . Practical implications If you previously cloned or forked the crmscript, database, data-access, or user-interface repo, you need to switch to using the superoffice-docs repo .   The URLs to some API references have changed: CRMScript : automation/crmscript/reference/index.html Trigger scripts : automation/trigger/reference/index.html Webhooks : automation/webhook/reference/index.html bLogic screen elements : ui/blogic/reference/index.html Content about custom fields , udef, user-defined fields, extra fields, and extra tables is grouped under custom-objects/ . The NetServer API options for contact, company, diary, document, project, quote, sale, and request now have /howto/ instead of /api/ in the URL. The pages of the CRMScript "Working with..." section are now in the above-mentioned API option sections. In conclusion We hope you find this useful and interesting! Please let us know what you think by providing feedback on our GitHub discussion board . Go check it out! Disclaimer: You will need a github account, but the good news is that registration is super simple!

Bergfrid Skaara Dias
thumb_up6 mode_comment0

Spelling in code

Spelling mistakes always hit you when you're not expecting it. The harsh reality is that people will judge you on it. Nothing can make you or your company lose credibility more quickly. But I write code, not literary fiction... Yet you put your writing in front of other developers. Daily.     A typo in a code comment might trip up your co-worker reviewing your code. Or perhaps it goes undetected for years until they attempt to refactor or extend the code - after you left the company. Meanwhile, the comment is propagated to a public API reference where it can affect your company and trip up an unknown number of developers. Did someone say support case? OK. But let's say the typo was not in a comment, but actual code like a method name, property, or enum? Thanks to your IDE, IntelliSense will propagate your initial mistake like wildfire throughout the code-base. Awesome! Never, ever feed the Mogwai after midnight.     As with all bugs: the earlier you catch it, the cheaper it is to fix it. Who does not like bugs in production? The thrill of patches and hot-fixes.  But do you realize that once a misspelling is in the released API you have to live with it or break compatibility? Auch!   SuperOffice.CRM.ArchiveLists.AppointmentExtenderBase.ColumnRecurrenceRuleId SuperOffice.CRM.ArchiveLists.AppointmentExtenderBase._colRecurrencId The solution Slow down, read the actual words on the screen, and not what your autopilot concludes is there. Use a code spell checker. (Both for creating and reviewing.) Get a second pair of eyes. Own your oops'es and do the non-code-related PR change. Options VS Code: Code Spell Checker (cspell) Visual Studio: VS2017andLater | VS2022andLater (NHunSpell) Your milage might vary but I'm sure there is a spell checker match for you too.   Personally, I go the VS Code route with Code Spell Checker plus Grammarly. For SuperOffice Docs , we have a shared dictionary in .vscode/settings.json in each repo. You can check it out on GitHub .     (The covfefe level in my bloodstream is low. Please excuse any typos.)

Bergfrid Skaara Dias
thumb_up3 mode_comment0

New Technical Forums

Hello fellow community members! So you might be wondering what happened to the forum structure, and I'd like to address that here and now. First and foremost, I apologize for any inconvenience it might have on your old bookmarks and/or saved favorites. It was decided to focus on the future and not dwell on the past. Search hasn't changed that much, and as long as you still have the same ending URL in those favorites, they will make good search terms to rediscover where those posts now reside.  That said, let me explain the mapping rules that went into the migration. Here is a list of the old forums... Technical Forums:---------------------------- Customer Service:       CRM Windows Application:   CRM Web Application:       eMarketing Application:   PocketCRM Application:    Online Operations Status: Hidden eMarketing:       Developer Forums:---------------------------- NS Core:                   NS Services:               Customer Service:          CRM Windows Application:   CRM Web Application:       CRM Online Development:    Continuous Database:       Developer Announcements:   There was quite a bit of overlap, and over time it became obvious that the club concept, and knowing and where to ask a question, could easily be confusing and perhaps even overwhelming. With the inevitable merger of the clubs, and having nearly identical listing of forums in each club, it would have been easy to just combine the two into a single similar grouping. However, even then the choices to know where to post a question could still be confusing. I mean, isn't the service client also a web application? Isn't emarketing part of the service client? So, in an attempt to simplify, the decision was made to consolidate the number of options. Thereby decreasing any anxiety and increasing the effectiveness and intuitiveness of using the technical forums. General Forums  - Technical Announcements: consolidated both technical and developer related announcements. API Forums  - Client library and tools: NetServer Core, Continuous Database  - Online development and web services: NetServer Services, Online Development  - Service and CRM Script: consolidate Tech and Dev Customer Service, eMarketing Technical Product Forums  - CRM Web Application: consolidate Tech and Dev CRM Web Application  - CRM Windows Application: consolidate Tech and Dev CRM Web Application  - CRM Mobile Application: migration of PocketCRM Application   I also have to mention that a lot of the posts from the old Technical Club were migrated to the new User Admin forums . We foresee questions pertaining to what you do in the clients going to the User Admin forums . The Technical forums are reserved for network/system administrators setting up and maintaining SuperOffice for onsite installations, as well building integrations and customizations using the API. All of the previous technical documentation now resides on SuperOffice Docs . Let's know if you have any trouble finding information on docs by submitting feedback . I get it. No one likes their cheese moved. However, I believe this is the right decision moving forward. I hope you now have a better understanding of the motivation behind it, and eventually agree.   

Tony Yates
thumb_up3 mode_comment0