Blog posts by Aniket Gadre

Blog posts by Aniket Gadre2026-03-12T02:21:00.0000000Zhttps://world.optimizely.com/blogs/aniket-gadre/ Optimizely World Optimizely Commerce vs Composable Commerce: What Should You Do with CMS 13?As organizations modernize their digital experience platforms, a common architectural question emerges: Should we continue using Optimizely Commerce with CMS 13, or move to a composable commerce platform? This decision is becoming increasingly important as companies adopt headless frontends, API-driven architectures, and AI-powered content workflows. While Optimizely continues to provide a strong enterprise CMS platform, the broader commerce ecosystem has evolved significantly in recent years. In this post, I'll break down the two primary approaches, the trade-offs between them, and how to determine which model is right for your organization. <hr /> <h2>The Traditional Optimizely Stack: CMS + Commerce</h2> Historically, most enterprise Optimizely implementations used a tightly integrated stack combining CMS and Commerce. <h3>Typical Architecture</h3> <pre><code>Frontend (MVC / Next.js) -> Optimizely CMS -> Optimizely Commerce Connect 14 -> Catalog / Cart /Orders </code></pre> In this model: <ul> <li>CMS manages content, pages, and marketing experiences.</li> <li>Commerce manages the product catalog, pricing, cart, checkout, and orders.</li> <li>Both systems run within the same application environment.</li> </ul> <h3>Advantages</h3> The integrated approach offers several benefits: <ol> <li>Strong content-commerce integration Editors can easily blend marketing content with product experiences. </li> <li>Built-in commerce functionality Commerce includes catalog management, promotions, pricing, carts, and order management. </li> <li>Mature enterprise platform Optimizely Commerce has powered many large-scale digital commerce implementations. </li> <li>Unified editorial experience Marketing and merchandising teams operate within a single system.</li> </ol> <h3>Challenges</h3> However, this architecture can introduce limitations: <ul> <li>Scaling commerce independently from CMS can be difficult.</li> <li>Deployments and releases are often tightly coupled.</li> <li>Customization can become complex over time.</li> <li>Innovation cycles may lag behind newer SaaS commerce platforms.</li> </ul> These challenges are one reason many organizations are exploring a different approach. <hr /> <h2>The Rise of Composable Commerce</h2> In recent years, many companies have shifted toward composable commerce architectures, where content and commerce platforms are separated and integrated through APIs. <h3>Typical Architecture</h3> <pre><code>Frontend (Next.js / React) -> Optimizely CMS 13 -> GraphQL / APIs -> Composable Commerce Platform </code></pre> Examples of composable commerce platforms include: <ul> <li>commercetools</li> <li>Shopify</li> <li>Elastic Path</li> </ul> In this model: <ul> <li>CMS focuses on content and experience</li> <li>Commerce platforms handle transactions, catalogs, pricing, and orders</li> <li>The frontend integrates both systems via APIs.</li> </ul> <h3>Benefits</h3> Composable commerce introduces several architectural advantages. <ul> <li>Independent scalability Commerce services can scale separately from content platforms.</li> <li>Faster innovation Modern SaaS commerce vendors release features rapidly.</li> <li>Best-of-breed architecture Organizations can choose specialized platforms for each capability.</li> <li>Better alignment with headless development API-first commerce platforms integrate seamlessly with frameworks like Next.js and React.</li> </ul> Trade offs: However, composable commerce also introduces complexity. <ul> <li>Integration work increases.</li> <li>Architecture governance becomes more important.</li> <li>Editorial experiences may require additional tooling to replicate traditional CMS-commerce workflows.</li> </ul> <hr /> <h2>Why This Conversation Is Happening Now</h2> Three major industry trends are driving this architectural shift. <h3>1. Headless Frontends</h3> Many organizations are moving to modern frontend frameworks such as Next.js and React. These frameworks work best with API-first services, making composable commerce platforms a natural fit. <h3>2. Rapid Innovation in Commerce Platforms</h3> Commerce vendors like commercetools and Elastic Path are delivering rapid innovation in areas such as: <ul> <li>subscription commerce</li> <li>marketplace models</li> <li>advanced promotions</li> <li>global scaling capabilities</li> </ul> <h3>3. Optimizely’s Strategic Focus</h3> Optimizely has been heavily investing in: <ul> <li>content management</li> <li>experimentation</li> <li>personalization</li> <li>AI workflows through Opal</li> </ul> Commerce remains part of the ecosystem, but many organizations are evaluating whether external commerce platforms better align with modern architecture strategies. <hr /> <h2>When Optimizely Commerce Still Makes Sense</h2> For many existing customers, staying with Optimizely Commerce remains the most practical choice. Continuing with Commerce Connect is typically ideal when: <ul> <li>You already operate an Optimizely Commerce implementation</li> <li>Catalog complexity is moderate</li> <li>Editorial and merchandising teams rely on tight CMS integration</li> <li>Replatforming costs would be significant</li> </ul> For these organizations, CMS 13 paired with Commerce 14 remains a stable and proven architecture. <hr /> <h2>When Composable Commerce Is the Better Choice</h2> Composable commerce may be the better option when: <ul> <li>Building a new commerce platform</li> <li>Operating at global scale</li> <li>Supporting marketplaces or subscription models</li> <li>Adopting microservices-based architectures</li> <li>Delivering experiences across multiple channels (web, mobile, kiosks, apps)</li> </ul> In these scenarios, separating the experience layer from the transaction engine can offer significant flexibility. <hr /> <h2>The Hybrid Model Many Enterprises Are Adopting</h2> Interestingly, many organizations are landing somewhere in the middle. Instead of replacing Optimizely CMS, they use it as the experience orchestration layer, while delegating commerce operations to a composable platform. <h3>Hybrid Architecture</h3> <pre><code>Next.js Frontend -> Optimizely CMS -> Composable Commerce API -> ERP / PIM / Payment Services </code></pre> In this approach: <ul> <li>CMS manages content and experience orchestration</li> <li>Commerce platforms handle transactions and catalog services</li> <li>Frontend applications unify the experience</li> </ul> <hr /> <h2>Final Thoughts</h2> <ul> <li>There is no universal answer to the Optimizely Commerce vs composable commerce question.</li> <li>For existing Optimizely customers, continuing with Commerce 14 is often the most pragmatic choice.</li> <li>For new digital commerce initiatives, however, many organizations are evaluating composable commerce platforms alongside Optimizely CMS to build more flexible architectures.</li> <li>The key is understanding your organization’s priorities: editorial workflows, architectural flexibility, innovation velocity, and long-term platform strategy.</li> <li>Optimizely CMS remains a powerful enterprise content platform. The real question is simply how commerce fits into the future architecture around it.</li> </ul>2026-03-12T02:21:00.0000000Z

Blog post

Creating a custom tool for Opal AI in Google Cloud using Python SDK<div class="markdown markdown-main-panel tutor-markdown-rendering enable-updated-hr-color"> <div class="markdown markdown-main-panel tutor-markdown-rendering enable-updated-hr-color"> I had the opportunity of participating in the Opal AI Hackathon challenge, where we built a custom tool using Optimizely's Opal Python SDK. This article walks you through building the tool in Python and deploying it securely on Google Cloud Run. The goal of this tool is to enable an Opal Agent to instantly create a fully-detailed Azure DevOps (ADO) User Story from a simple request. <h2>The Core: The Optimizely Opal Tools SDK</h2> Optimizely provides a variety of SDKs to connect to their services. For an Opal Agent to use your service, it first needs a blueprint defining what your tool does, what inputs it needs, and how to execute it. This blueprint is called the Tool Manifest, exposed via a standardized `/discovery` endpoint. The Python Opal Tools SDK abstracts away the complexity of managing this API contract. By simply decorating a standard Python function with `@tool`, the SDK automatically handles: <ol> <li> Generating the required OpenAPI-compatible Discovery Manifest at '/discovery' </li> <li> Routing incoming `POST` requests to the correct function. </li> <li> Validating and parsing the JSON input based on your Pydantic model. </li> </ol> <h3>Tool Service Code (main.py)</h3> The main.py file is the main entry point of your code and the service uses FastAPI for routing and the Opal SDK for tool definition. You can definine a single application instance that hosts multiple tool endpoints. In this case, I built a single tool endpoint. <pre class="language-python"><code>import os import base64 import httpx import pdb from fastapi import FastAPI from pydantic import BaseModel, Field from opal_tools_sdk import ToolsService, tool from dotenv import load_dotenv # --- Configuration --- # In production, load these from os.environ for security ADO_ORG = "rightpoint" ADO_PROJECT = "Optimizely-Opal-Challenge-2025" load_dotenv() ADO_PAT = os.environ.get("ADO_PAT") tag = "opal-2025" # Encode PAT for Basic Auth auth_str = f":{ADO_PAT}" b64_auth = base64.b64encode(auth_str.encode()).decode() HEADERS = { "Authorization": f"Basic {b64_auth}", "Content-Type": "application/json-patch+json" } # --- App Setup --- app = FastAPI() # This initializes the /discovery endpoint automatically service = ToolsService(app) # --- Parameters Model --- class UserStoryParams(BaseModel): title: str = Field(..., description="The title of the user story") description: str = Field(..., description="Detailed description of the user story") acceptance_criteria: str = Field(None, description="Acceptance criteria for the story") # --- The Tool Definition --- @tool( name="create_ado_user_story", description="Creates a new User Story in Azure DevOps with a title and description.", ) async def create_ado_user_story(params: UserStoryParams): """ Creates a User Story in Azure DevOps. """ url = f"https://dev.azure.com/{ADO_ORG}/{ADO_PROJECT}/_apis/wit/workitems/$User%20Story?api-version=7.1" # Azure DevOps requires a JSON Patch document payload = [ { "op": "add", "path": "/fields/System.Title", "value": params.title }, { "op": "add", "path": "/fields/System.Description", "value": params.description }, { "op": "add", "path": "/fields/System.Tags", "value": tag } ] if params.acceptance_criteria: payload.append({ "op": "add", "path": "/fields/Microsoft.VSTS.Common.AcceptanceCriteria", "value": params.acceptance_criteria }) response = None try: # Use httpx.AsyncClient for non-blocking I/O inside an async function async with httpx.AsyncClient(timeout=30.0) as client: response = await client.post(url, headers=HEADERS, json=payload) response.raise_for_status() data = response.json() # Return a dictionary directly. This dictionary is the FINAL return value # and should not be awaited by the SDK's wrapper. return { "status": "success", "id": data.get("id"), "link": data.get("_links", {}).get("html", {}).get("href"), "message": f"User Story #{data.get('id')} created successfully." } except httpx.RequestError as e: # Handle all httpx communication errors (DNS, connection, etc.) response_text = "No response body available." if response is None else response.text print(f"HTTPX Request Error: {str(e)}\nDetails: {response_text}") return { "status": "error", "message": f"Connection/Request Error: {str(e)}", "details": response_text } except Exception as e: # Handle all other exceptions (including raise_for_status errors) response_text = "N/A" if response is not None and response.text: response_text = response.text print(f"Unexpected Error: {str(e)}\nResponse Body: {response_text}") return { "status": "error", "message": f"An unexpected error occurred: {str(e)}", "details": response_text } # Run locally for testing if __name__ == "__main__": import uvicorn # CRITICAL: Ensure you are running this command, which uses the uvicorn async server. uvicorn.run(app, host="0.0.0.0", port=8000)</code></pre>   When writing tools for high-performance cloud environments like Cloud Run, it's essential to use asynchronous (async) code. This prevents a single network request (like waiting for the slow ADO API response) from blocking the entire Python process, allowing the server to handle dozens of requests simultaneously. We achieve this by defining the function as `async def` and using the asynchronous HTTP client, `httpx`. The tool constructs the ADO JSON Patch payload, uses an injected Personal Access Token (PAT) for authentication, and executes the asynchronous network call. <div class="attachment-container unknown"></div>   <h2>Deployment: Building on Google Cloud Run</h2> To make your tool publicly accessible to Optimizely Opal, we deploy it as a serverless container on Google Cloud Run. <h3>Deployment Files</h3> We use a `requirements.txt` to manage dependencies and a `Dockerfile` for the deployment. a) Dependencies (`requirements.txt`): This tells the application the required dependencies to install for the application to run successfully. <pre class="language-python"><code>fastapi==0.110.0 uvicorn==0.27.1 requests==2.31.0 optimizely-opal.opal-tools-sdk pydantic python-dotenv</code></pre> <div class="attachment-container unknown"></div> b) Container Blueprint (`Dockerfile`): <pre class="language-python"><code># Use the official lightweight Python image. # https://hub.docker.com/_/python FROM python:3.12-slim # Allow statements and log messages to immediately appear in the Knative logs ENV PYTHONUNBUFFERED True # Copy local code to the container image. ENV APP_HOME /app WORKDIR $APP_HOME COPY . ./ # Install production dependencies. RUN pip install --no-cache-dir -r requirements.txt # Run the web service on container startup. Here we use the gunicorn # webserver, with one worker process and 8 threads. # For environments with multiple CPU cores, increase the number of workers # to be equal to the cores available. # Timeout is set to 0 to disable the timeouts of the workers to allow Cloud Run to handle instance scaling. CMD exec uvicorn main:app --host 0.0.0.0 --port $PORT</code></pre> This container ensures security by running the application under a non-root user and explicitly defines the startup command. <div class="attachment-container unknown"></div> <h3>Deployment Steps (gcloud CLI)</h3> <ol> <li> Secure the PAT: Upload your Azure DevOps PAT to Google Cloud Secret Manager (recommended, as shown in previous context). </li> <li> Build and Deploy: Use the `gcloud` CLI to build the container from source and deploy, mapping the secret to the `ADO_PAT` environment variable. </li> </ol>  <div class="code-block ng-tns-c4228668850-44 ng-animate-disabled ng-trigger ng-trigger-codeBlockRevealAnimation"> <div class="formatted-code-block-internal-container ng-tns-c4228668850-44"> <div class="animated-opacity ng-tns-c4228668850-44"> Enable APIs (if necessary): Note you may need to enable the google cloud billing for certain services to work. gcloud services enable cloudbuild.googleapis.com run.googleapis.com secretmanager.googleapis.com Build and run the application: gcloud run deploy opal-ado-tool \     --region us-central1 \     --source . \     --allow-unauthenticated \ Integrating the Tool into Optimizely Opal Once deployed, your service provides a public URL (e.g., `https://opal-ado-tool-xyz.run.app`). Register Discovery Endpoint: In the Optimizely Opal UI, register the tool using the public URL appended with `/discovery`. Agent Workflow: Configure an Agent Workflow step to first synthesize the necessary ADO parameters (Org, Project, Title, Description) from an unstructured request, and then automatically feed that structured JSON output directly into the `create_ado_user_story` tool. By bridging the gap between your conversational AI input and your crucial development systems, you empower your Optimizely agents to become powerful, action-oriented contributors to your product delivery lifecycle.   </div> </div> </div> </div> </div>2025-12-01T03:06:59.0000000Z

Blog post

Getting around asynchronous limitations in Optimizely (Visitor Groups etc.)Optmizely has a powerful personalization engine that allows creating custom Audiences/Visitor groups. It comes with one limitation though. It doesn't support ASYNC operations. The below solution can work for any scenario where you cannot run async operations in Optimizely.  Here's a real world use case and how we got around it. Personalizing user experiences often starts with knowing where your visitor is coming from. One lightweight approach is to translate the user's IP address into a zip code to personalize the experience for users depending on their location (state run promotion, etc.). In Optimizely CMS 12 (running on ASP.NET Core 8), on of the way to do this is by using middleware. <hr /> <h2>Why Middleware?</h2> Visitor Groups has a key limitation: visitor group criteria must run synchronously. This means you can’t safely call an external API or await an async lookup when evaluating a visitor group without causing thread block calls to the external service, which rules out many IP-to-zip services. ASP.NET Core middleware, on the other hand, runs for every request (that can be filtered) and fully supports async operations. Using AsyncHelper.RunSync() as outlined <a href="https://marisks.net/2017/04/02/calling-async-methods-within-episerver-events/">here</a> isn't a scalable solution and can cause thread pool starvation and deadlocks in your application. This makes it the ideal place for concerns like geolocation, logging, authentication, and request enrichment. By resolving the zip code once at the start of the pipeline, you avoid duplicate lookups in controllers, block controllers, or views at the same time avoid blocking calls to external services. <hr /> <h2>Step 1: Create a Request-Scoped Container</h2> We’ll use a scoped class to store the resolved zip code so it’s easily accessible through DI. <pre class="language-csharp"><code>public sealed class GeoContext { public string? ZipCode { get; set; } }</code></pre> <pre> </pre> <hr /> <h2>Step 2: Define an IP → Zip Resolver</h2> This is your service that turns an IP address into a zip code. You can use a 3rd-party API, MaxMind, or your own data source. <pre class="language-csharp"><code> public interface IZipFromIpResolver { Task<string?> GetZipFromIpAsync(string ip, CancellationToken ct = default); } </code></pre> <pre> </pre> <h2>Step 3: Implement Middleware</h2> The middleware gets the client IP, calls the resolver, and stores the result in GeoContext <pre class="language-csharp"><code> public sealed class GeoZipMiddleware { private readonly RequestDelegate _next; public GeoZipMiddleware(RequestDelegate next) => _next = next; public async Task InvokeAsync(HttpContext context, GeoContext geo, IZipFromIpResolver resolver) { // Filter out any paths to avoid calling the service on these requests var path = httpContext.Request.Path.Value ?? ""; if (!path.StartsWith("/assets", StringComparison.OrdinalIgnoreCase) && !path.StartsWith("/static", StringComparison.OrdinalIgnoreCase) && !path.StartsWith("/api/custom", StringComparison.OrdinalIgnoreCase) && !path.Contains("/globalassets", StringComparison.OrdinalIgnoreCase) && !path.Contains("/.well-known", StringComparison.OrdinalIgnoreCase) && !path.Contains("/siteassets", StringComparison.OrdinalIgnoreCase) && !path.Contains("/Errors", StringComparison.OrdinalIgnoreCase) && !path.Contains("/contentassets", StringComparison.OrdinalIgnoreCase)) // Optimizely blobs { var ip = context.Connection.RemoteIpAddress?.ToString(); if (!string.IsNullOrWhiteSpace(ip)) { try { // Call your GeoLocation Service geo.ZipCode = await resolver.GetZipFromIpAsync(ip); // You can also save it within the httpContext httpContext.Items["ZipCode"] = geo.ZipCode; } catch { // log if needed; don’t block the request } } } await _next(context); } } </code></pre> <pre> </pre> <h2>Step 4: Register Services & Middleware</h2> Update Program.cs <pre class="language-csharp"><code>var builder = WebApplication.CreateBuilder(args); // Add request-scoped container builder.Services.AddScoped<GeoContext>(); // Add resolver implementation // builder.Services.AddSingleton<IZipFromIpResolver, MyIpResolver>(); builder.Services.AddHttpContextAccessor(); var app = builder.Build(); // Use middleware early in the pipeline app.UseMiddleware<GeoZipMiddleware>(); app.UseRouting(); app.UseAuthorization(); app.MapContent(); app.Run();</code></pre>   <hr /> <h2>Step 5: Use in Controllers, Blocks, or Views</h2> Since GeoContext is scoped, you can inject it anywhere. You can also use the httpContext.Items to retrieve the value (set in the middleware) <pre class="language-csharp"><code> public override bool IsMatch(IPrincipal principal, HttpContext httpContext) { var zipCode = httpContext.Items["ZipCode"]; // do something with it return true; }</code></pre> <pre> </pre> <hr /> <h2>Notes & Best Practices</h2> <ul> <li> Caching: IP-to-zip lookups can be expensive. Use ISynchronizedObjectCache or a distributed cache to reduce API calls. </li> <li> Privacy: Treat IP and location data as personal information (GDPR/CCPA). Avoid persisting unless you have a clear use case. </li> <li> Performance: Consider skipping static asset and other URL requests inside your middleware for speed. </li> </ul> <hr /> <h2>Wrapping Up</h2> By leveraging ASP.NET Core middleware in Optimizely CMS 12, you can easily enrich each request with geolocation or any other data. This is powerful and can significantly improve the performance of the website by removing blocking calls from the application. 2025-08-16T11:09:08.0000000Z

Blog post

Part 1: Planning and estimation for Upgrade (CMS 12/Commerce 14) In this series, I will talk about the Optimizely CMS/Commerce upgrade project(s) with some do's and don'ts as well as tips & tricks for a successful implementation. We can all agree depending on the complexity of the implementation, the ugprade project has a potential to go off track pretty easily. This blog post will allow you to get ahead of some of these challenges.  5P's principle: Proper Planning Prevents Poor Performance. In Part 1 of this series let's talk through the most important (& often neglected) phase - "Planning and Estimatation".  <h2>Planning & Estimation</h2> This is one of the most difficult part of the process. How do you estimate an upgrade? Unfortunately, I don't have a silver bullet, as each project is unique but here are a few critical things to consider that will help you plan and estimate it better. Onboarding & kickoff: If you are planning to use a new sidecar team for the upgrade, you need to account for any setup/onboaring time for new developers + kickoff.  Customizations: Take inventory of the all the customizations to the core product. This is by far the biggest variable in the estimate and can cause the project to go off track quickly if you don't have a plan for how you plan to support it. Third Party Integrations: With the upgrade the underlying engine needs to be upgraded to .NET Core. It will be useful to document all third party integrations including nuget packages that rely on the old .NET framework & haven't been updated to support the new .NET Core architecture. You may need to work with the client to find alternatives or remove this functionality completely.  Commerce Manager: Commerce Manager will no longer available in the new Commerce 14 and will have Order Manager instead. Ensure you are documenting any updates/customizations that need to be supported in the new Order Manager for processing your orders. Linux Containers: The new DXP is hosted in Linux containers unlike the existing DXP which is hosted on Window's servers. This is a huge diference as Windows Forms WPF and other Window specific packages will not work in the the Linux containers. This is difficult to anticipate as the upgrade project may work perfectly fine locally but throw random errors in the new DXP.  Did you know: Linux has removed support for TLS1.0 & TLS 1.1 certificates? We ran into this issue after deploying to DXP although it worked perfectly fine locally (windows v/s linux).  Breaking Changes: There are lot of breaking changes in this version. I would recommend carefully reviewing these <a href="https://docs.developers.optimizely.com/content-management-system/docs/breaking-changes-in-content-cloud-cms-12">here</a> before the start of the project to avoid any big surprises during implementation. Ongoing development & branching: If you have a huge team of developers working on the existing project (we did in this case), you need to keep the upgrade branch updated regularly. Have a solid branching strategy figured out on keeping the old and new in sync. This along with ongoing QA can be challenging as new functionality and features will need to be merged in and tested.  Deployments: Make sure you account for creating build & release pipelines, CI/CD etc. There may be instances where the existing DXP deployment pipelines do not work with the new DXP. In our project, the bundled js and css files weren't getting deployed correctly (due to differences in .NET & .NET Core build).  Content Freeze: This may not impact the budget but does affect the timeline. Content freezes are essential and need to be co-ordinated with the client as we get closer to the finish line. Ensure you are accounting for how long the content freeze will last and  Code freeze: It may be a good idea to freeze any code development (or keep it to minor bug fixes) before going LIVE to prevent introducing new bugs. Adding new features may add new defects, which could potentially delay the Go LIVE. Go Live Prep: Ensure the right people are available for GO LIVE, ex: IT team with DNS access needs to be involved to switch from old to the new DXP environments (this is a two step process).  Add Buffer: Always buffer your estimates for unknowns. Depending on the complexity of the project, there's a chance you missed something which could potentially take hours (if not days) to figure out & completely derail the project. Hope this helps! In Part 2 of thia series I will talk about implementation & known issues to bypass. 2023-12-19T23:39:30.0000000Z

Blog post

Serializable Carts - Website crash? Wait what?...Stop and do this right now: If you are running a transactional ecommerce website on Optimizely please check the health and size of your commerce database in Application Insights. This gets typically overlooked unless you have an alert setup or there's a issue on the website. Okay maybe I lied in the title. It won't be a website crash but none of the carts can be created (naturally no orders can be created until this issue is resolved). This will be SEV 1 issue with the client yelling on the phone to get this resolved ASAP. What are Serializable Carts: Serializable carts have been around for a while so it's not a net new functionality. Documentation here: <a href="https://docs.developers.optimizely.com/commerce/v14.0.0-commerce-cloud/docs/serializable-carts?_gl=1*t9pqkp*_ga*MTUwOTA5MDEyMS4xNjc3MjY2Mjcy*_ga_C7SLJ6HMJ5*MTY3NzU5NjExNy4xMS4xLjE2Nzc1OTYzNTQuNTAuMC4w">https://docs.developers.optimizely.com/commerce/v14.0.0-commerce-cloud/docs/serializable-carts</a> The SerializableCarts table is pretty simple. The data column holds the entire cart as a JSON string (which can use up some good bytes in the DB). <img src="/link/069820c1f71a450da10e846c3e0cc1fa.aspx" /> Serializable carts are created/updated in the database every time a user adds/updates an item to the cart (because of SaveCart() calls in your code). Saving carts in the database is a useful piece of functionality for keeping the users' history of products as well as retrieving their saved items even after they close their browser (as long as they don't delete cookies). Seriaziable Carts are also used for 'Wishlist' to create favorites or other lists that are stored in the database. Anything wrong here? <pre class="language-csharp"><code> public ICart GetInMemoryCart(Guid contactGuid) { // Load cart to get a fake cart, if not create one var cart = _orderRepository.LoadOrCreateCart<ICart>(contactGuid, "Default"); return cart; } public void CallingMethodDoPromotionCalculations() { // Get a fake cart to do custom calculations var cart = GetInMemoryCart(Guid.NewGuid()); if (cart != null) { // Add line items to the cart // Basic shipping address etc. // Do promotion calculations on the cart to check if user will qualify // More code _orderRepository.Save(cart); } // Return the results of the calculations }</code></pre> What's wrong? If you couldn't figure out the problem the issue isn't evident at first sight. The above code will create a new cart with a new GUID (meant to be for in-memory calculations etc.) in the database. Now if this code runs (on say home page), every time the user browses to the website (whether they add items to the cart or not) you got a problem. There are 2 things to watch out for: <ol> <li>It's using the LoadOrCreate() creating a cart with a new GUID every time, instead of using something like CustomerContext.Current.CurrentContactId</li> <li>It's calling the SaveCart() which actually commits this cart to the database with the new Customer GUID.</li> </ol> Death by a thousand paper cuts: Here's a scenario to consider where this issue can go unnoticed for days/months until your database is full: <ol> <li>The above piece of code was accidentally introduced on a frequently visited page and it's creating thousands of carts every day. </li> <li> Well luckily Optimizely provides a scheduled job called "Remove expired carts" that deletes carts that haven't been modified in the last 30 days and by default runs once every day. </li> <li>The issue is the scheduled job won't get to these fake/junk carts until 30 days later and in the meanwhile created 1 million carts/rows in the database. </li> <li>Well we have the scheduled job no issue right? (hopefully!). However, now when the scheduled job tries to get all serializable carts to delete within the last 30 days it may start failing due to timeouts. Then your website is doomed....very slowly :) because if the failing scheduled job goes unnoticed for a while you are accumalating carts and absolutely nothing to purge them. </li> <li>Soon enough the SerializableCarts table will grow expoentially and eat up all the allocated database space (currently set to 250 GB in DXP)</li> <li>When this happens in production, no new carts will be created. God forbid if it happens during peak traffic hours or even worse on Cyber Monday this will be SEV 1 right away!!! </li> </ol> Short Term Fix: <ol> <li>Call/Email Optimizely customer support and ask them to increase the database size from 250GB to 500 GB. This will resolve the issue right away and your website will be operational and buy you some time to get to the bottom of this issue.</li> </ol> Long term Solution: <ol> <li>Check application insights to see how long this has been going on and also get a sense of daily increase in the database size </li> <li>Ask support to run the following query to get the size of the tables in the ecommerce database. If this is a seriazible cart issue, the table will show up to the top of the list.  <pre class="language-markup"><code>SELECT t.NAME AS TableName, s.Name AS SchemaName, p.rows, SUM(a.total_pages) * 8 AS TotalSpaceKB, CAST(ROUND(((SUM(a.total_pages) * 8) / 1024.00), 2) AS NUMERIC(36, 2)) AS TotalSpaceMB, SUM(a.used_pages) * 8 AS UsedSpaceKB, CAST(ROUND(((SUM(a.used_pages) * 8) / 1024.00), 2) AS NUMERIC(36, 2)) AS UsedSpaceMB, (SUM(a.total_pages) - SUM(a.used_pages)) * 8 AS UnusedSpaceKB, CAST(ROUND(((SUM(a.total_pages) - SUM(a.used_pages)) * 8) / 1024.00, 2) AS NUMERIC(36, 2)) AS UnusedSpaceMB FROM sys.tables t INNER JOIN sys.indexes i ON t.OBJECT_ID = i.object_id INNER JOIN sys.partitions p ON i.object_id = p.OBJECT_ID AND i.index_id = p.index_id INNER JOIN sys.allocation_units a ON p.partition_id = a.container_id LEFT OUTER JOIN sys.schemas s ON t.schema_id = s.schema_id WHERE t.NAME NOT LIKE 'dt%' AND t.is_ms_shipped = 0 AND i.OBJECT_ID > 255 GROUP BY t.Name, s.Name, p.Rows ORDER BY TotalSpaceMB DESC, t.Name</code></pre> </li> <li>Ask Optimizely support to run the following script to clean up the ecommerce database SerializableCarts table (PLEASE TEST THIS ON LOCAL AND OTHER LOWER ENVIRONMENTS FIRST) <pre class="language-markup"><code>-- The -300 is the lookback (depends on how far back this issue has been around. The script will need to be run in increments by support -300, -200, -100 down to -30. DELETE from SerializableCart where Modified < DATEADD(day, -300, GETDATE()) and Name != 'WishList'</code></pre> </li> <li>Lower the frequency of the "Remove Expired Carts" scheduled job to run every hour or multiple times in a day (this wouldn't help unless you clean up the database first) </li> <li>Investigate the root cause with special attention to SaveCart(), LoadOrCreateCart() and LoadCart(). </li> <li>Setup alerts with Optimizely to be notified when the database size increases 20% more than the baseline. </li> <li>Manually check the scheduled job is functioning regularly to avoid the same problem from happening again. </li> </ol> Happy coding!  2023-03-01T04:45:05.0000000Z

Blog post

Azure Service Bus Messaging (Topic/Queues) for transferring data between external PIM/ERP to OptimizelyOptimizely provides a PIM solution as a part of the DXP package. More information here: <a href="https://www.optimizely.com/product-information-management/">https://www.optimizely.com/product-information-management/</a> More often that not, clients have their existing PIM and/or ERP systems that feed other systems in their organization. For ex: Their PIM/ERP system may be serving physical stores, running reports, feeding their invoicing details and the SOURCE of TRUTH. There are numerous blog posts on importing catalog one time into Optimizely using the out-of-the-box Optimizely APIs. Needless to say, as updates are made to say pricing, inventory, assets, delivery charges, taxes etc. in ERP/PIM/DAM, we need to keep that data synchronized in the Optimizely catalog. to ensure the customers see the most up-to-date information on the website as quickly as possible. This requires a strategy to figure out how to move content between two systems and do it on a regular fault tolerant basis. A quick solution is the use of Optimizely's scheduled job to fetch data and update it in the database. though there are some limitations with a scheduled job - timeouts, low fault tolerance, logging, speed, resource constraints, alerting etc.  Another alternative is to <a href="https://learn.microsoft.com/en-us/azure/service-bus-messaging/service-bus-queues-topics-subscriptions">Azure Service Bus Messaging</a> to line up the product updates from the source system (client's PIM/ERP) and synchronize it to the Optimizely catalog on a configurable schedule. Azure Service bus have a lot of advantages as described below and you can also read up online.  Advantages: <ul> <li>Message Sessions</li> <li>Auto-forwarding</li> <li>Dead-lettering</li> <li>Scheduled Delivery</li> <li>Message deferral</li> <li>Transactions</li> <li>Auto-delete on idle</li> <li>Duplicate detection</li> <li>Geo Disaster recovery</li> </ul> You can use the Azure Service Bus .NET SDK for integration: <a href="https://learn.microsoft.com/en-us/dotnet/api/overview/azure/service-bus?preserve-view=true&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;view=azure-dotnet">https://learn.microsoft.com/en-us/dotnet/api/overview/azure/service-bus?preserve-view=true&view=azure-dotnet</a> Strategy: We have used the following strategy on a huge B2C retail client and works really well.   <ol> <li>Our custom C# function/console app (extract job) deployed on Azure gets all products that have been updated in the last 'x' mins/hours by pinging the custom endpoint provided by client</li> <li>This function app is run using a 'TimerTrigger' configurable in Azure function app configuration. More info on function apps: <a href="https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-your-first-function-visual-studio?tabs=in-process">https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-your-first-function-visual-studio?tabs=in-process</a></li> <li>This function app is responsible for getting the data from the endpoint, serializing each message as a JSON and send it to the ASB topic (product extract topic)</li> <li>A second custom C# function app (transload job) which was subscribed to the above topic in ASB using 'ServiceBusTrigger' (executes every time there's a new message)</li> <li>This function app's job was to read the message from the topic, deserialize it and update the product item using Optimizely Service API</li> </ol> Diagram: <img src="/link/862c73d87f444d0fbb3d0e3304447413.aspx" /> Sample Code (Export Job): <pre class="language-csharp"><code>namespace ClientNamespace.Export.Features.CartCheckout.TaxSync { using System; using System.Linq; using System.Net.Http; using System.Threading; using System.Threading.Tasks; using Microsoft.Azure.WebJobs; using ClientNamespace.Export.Core.Features.CartCheckout.TaxRateSync.Models; using ClientNamespace.Export.Core.Features.Infrastructure.Azure.Constants; using ClientNamespace.Export.Core.Features.Infrastructure.Azure.Services; using ClientNamespace.Export.Core.Features.Infrastructure.Logging; using ClientNamespace.Export.Features.Infrastructure.Azure.Constants; using ClientNamespace.Export.Features.Infrastructure.Azure.Extensions; using ClientNamespace.Export.Features.Infrastructure.Azure.Services; using ClientNamespace.Export.Features.Infrastructure.Rfapi.Clients; using Serilog; using Serilog.Core; using ConnectionStringNames = ClientNamespace.Export.Core.Features.Infrastructure.Azure.Constants.ConnectionStringNames; using ExecutionContext = Microsoft.Azure.WebJobs.ExecutionContext; public class TaxRatesExportFunction { private const int ShortCircuit = 100_000; private IHttpClientFactory _clientFactory; public TaxRatesExportFunction(IHttpClientFactory clientFactory) { _clientFactory = clientFactory; } #if !DEBUG // remove this line to run locally as a console app [FunctionName("TaxRatesExport")] #endif public async Task Run( [TimerTrigger( ScheduleExpressions.TaxRatesExport, RunOnStartup = false)] TimerInfo myTimer) { var log = LoglevelWrapper.WrapLogger(Log.Logger); try { log.Information("Starting TaxRatesExportFunction: {starttime}", DateTime.UtcNow); using (var topicMessageSender = new TopicMessageSender(ConnectionStringNames.ServiceBusTaxRates, TopicNames.TaxRates, log)) { var taxRates = await apiClient.TaxesAllAsync(); // custom endpoint from the client var export = new TaxRateExport { TaxRates = taxRates .Select(x => new TaxRate { Percentage = x.TaxRate ?? 0.000, PostalCode = x.PostalCode, TaxCode = x.TaxCode, TaxableDelivery = x.TaxableDelivery, TaxablePlatinum = x.TaxablePlatinum, }) .ToList(), }; // Send the message to the topic to be consumed by the the transload function app try { var message = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(export))) { MessageId = Guid.NewGuid().ToString(), SessionId = "sesionid", }; string connectionString = Environment.GetEnvironmentVariable("connectionStringName"); if (string.IsNullOrEmpty(connectionString)) { connectionString = Environment.GetEnvironmentVariable($"CUSTOMCONNSTR_{"connectionStringName"}"); } var topicClient = new TopicClient(connectionString, "topicName", RetryPolicy.Default); await topicClient.SendAsync(message); } catch (Exception ex) { // logging } } } catch (Exception ex) { log.Error(ex, "Unhandled exception in TaxRatesExportFunction {exception}", ex); } finally { log.Information("TaxRatesExportFunction Complete: {endtime}", DateTime.UtcNow); } } } } </code></pre> Sample code Import job: <pre class="language-csharp"><code>namespace .Website.Import.Features.CartCheckout.TaxSync { using System; using System.Net.Http; using System.Threading.Tasks; using Infrastructure.Azure.Constants; using Microsoft.Azure.WebJobs; using Newtonsoft.Json; using ClientNamespace.Export.Core.Features.CartCheckout.TaxRateSync.Models; using ClientNamespace.Export.Core.Features.Infrastructure.Azure.Constants; using ClientNamespace.Export.Core.Features.Infrastructure.Logging; using .Website.Core.Features.Infrastructure.Episerver.Clients; using Serilog; using Serilog.Context; using ConnectionStringNames = ClientNamespace.Export.Core.Features.Infrastructure.Azure.Constants.ConnectionStringNames; public class TaxRatesImportFunction { private readonly IHttpClientFactory _clientFactory; public TaxRatesImportFunction(IHttpClientFactory clientFactory) { _clientFactory = clientFactory; } #if !DEBUG // Remove this to run locally (will be triggered when it sees a message on the topic it's subscribed to) [FunctionName(FunctionNames.TaxRatesImport)] #endif public async Task Run( [ServiceBusTrigger( TopicNames.TaxRates, SubscriptionNames.TaxRates, Connection = ConnectionStringNames.ServiceBusTaxRates, IsSessionsEnabled = true)] string mySbMsg) { var log = LoglevelWrapper.WrapLogger(Log.Logger); try { log.Information("Starting TaxRatesImportFunction: {starttime}", DateTime.UtcNow); log.Debug("Tax Rates Import Message: {message}", mySbMsg); TaxRateExport export = null; try { // Get taxes from topic queue export = JsonConvert.DeserializeObject<TaxRateExport>(mySbMsg); } catch (Exception ex) { log.Error(ex, "Could not JSON deserialize tax rates message {message} with exception {exception}", mySbMsg, ex); } if (export?.TaxRates == null) { log.Warning("Tax rates deserialized, but data was null"); return; } // Load taxes into Episerver var serviceApiClient = EpiserverApiClientFactory.Create(log, _clientFactory); foreach (var taxRate in export.TaxRates) { try { using (LogContext.PushProperty("importtaxrate", taxRate.TaxCode)) { // Update the taxes table (either custom endpoint or using Service API) await serviceApiClient.SaveTaxRateAsync(taxRate); } } catch (Exception ex) { // Don't fail the group // Custom logic to handle exception when updating in the Optimizely dtabase. } } } catch (Exception ex) { log.Error(ex, "Unhandled exception in TaxRatesImportFunction {exception}", ex); } finally { log.Information("TaxRatesImportFunction Complete: {endtime}", DateTime.UtcNow); } } } } </code></pre> As you see, with minimal code you can create a more fault tolerant synchronization to the optimizely database. You can now visualize this scaling to other areas of your website. For ex: We have scaled this system to automate processing of orders - As orders come in, the serialized order object is placed on the Azure service bus for automated processing all the way to completing the orders. Yes the client's IT team needs to write some code to automate it on their side but it has saved them hundred's of thousands of dollars in costs of manually updating each order by a keying team member.  Can you think of other ways to scale the Optimizely system to use Azure Service Bus Messaging?  Happy coding!2023-02-27T03:49:41.0000000Z

Blog post

ChatGPT/OpenAI integration for text generation using Prompt in OptimizelyHere's how you can use a simple publishing event to generate content using OpenAI. The code is pretty simple - I will avoid getting into too many details as Tomas has done a wonderful job of explaining it in his blog post here: <a href="https://www.gulla.net/en/blog/integrating-generative-ai-in-optimizely-cms-a-quick-test-with-openai/">https://www.gulla.net/en/blog/integrating-generative-ai-in-optimizely-cms-a-quick-test-with-openai/</a> ...And from Allan here: <a href="https://www.codeart.dk/blog/2022/11/ai-assisted-content-creation---in-optimizely-cms--commerce-ai-series---part-2/">https://www.codeart.dk/blog/2022/11/ai-assisted-content-creation---in-optimizely-cms--commerce-ai-series---part-2/</a>  Here's sample code which has been requested by a few people.  <pre class="language-csharp"><code>namespace ClientName.CMS.Features.Sample { using System; using System.Collections.Generic; using System.Linq; using System.Net.Http; using System.Threading.Tasks; using System.Web; using EPiServer; using EPiServer.Core; using EPiServer.Framework; using EPiServer.Framework.Initialization; using EPiServer.ServiceLocation; using Newtonsoft.Json; using ClientName.CMS.Features.Basics.RichTextBlock.Models; using ClientName.Common.Features.Foundation.Threading.Utilities; [InitializableModule] [ModuleDependency(typeof(EPiServer.Web.InitializationModule))] public class OpenAIBlockInitialization : IInitializableModule { private static readonly HttpClient _client = new HttpClient(); private readonly string _apiKey = "YOUR API KEY GOES HERE"; // You can generate it here: https://platform.openai.com/account/api-keys public void Initialize(InitializationEngine context) { // Add initialization logic, this method is called once after CMS has been initialized var contentEvents = ServiceLocator.Current.GetInstance<IContentEvents>(); contentEvents.PublishingContent += ContentEvents_PublishingContent; } public async Task<dynamic> SendRequestAsync(string model, string prompt, int maxTokens) { var requestUrl = "https://api.openai.com/v1/engines/" + model + "/completions"; var requestData = new { prompt = prompt, max_tokens = maxTokens }; var jsonRequestData = JsonConvert.SerializeObject(requestData); var requestContent = new StringContent(jsonRequestData, System.Text.Encoding.UTF8, "application/json"); _client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _apiKey); var response = await _client.PostAsync(requestUrl, requestContent); response.EnsureSuccessStatusCode(); var responseContent = await response.Content.ReadAsStringAsync(); var responseData = JsonConvert.DeserializeObject<dynamic>(responseContent); return responseData; } private void ContentEvents_PublishingContent(object sender, EPiServer.ContentEventArgs e) { try { if (e.Content != null) { if (e.Content is RichTextBlock richTextBlock) { var blockData = e.Content as RichTextBlock; string textToOpenAI = blockData.OpenAIPrompt; // Call Open AI and get results var response = AsyncHelper.RunSync(async () => await SendRequestAsync("text-davinci-003", textToOpenAI, 3000)); blockData.OpenAIGeneratedText = response?.choices[0]?.text; } } } catch (Exception ex) { // Optinal logging } } public void Uninitialize(InitializationEngine context) { // Add uninitialization logic var contentEvents = ServiceLocator.Current.GetInstance<IContentEvents>(); contentEvents.PublishingContent -= ContentEvents_PublishingContent; } } }</code></pre> AsyncHelper class to run async method synchronously (due to initialization functions limitations) <pre class="language-csharp"><code>namespace ClientName.Common.Features.Foundation.Threading.Utilities { using System; using System.Threading; using System.Threading.Tasks; public static class AsyncHelper { private static readonly TaskFactory TaskFactory = new TaskFactory(CancellationToken.None, TaskCreationOptions.None, TaskContinuationOptions.None, TaskScheduler.Default); /// <summary> /// Executes an async Task method which has a void return value synchronously /// USAGE: AsyncUtil.RunSync(() => AsyncMethod()); /// </summary> /// <param name="task">Task method to execute</param> public static void RunSync(Func<Task> task) => TaskFactory.StartNew(task).Unwrap().GetAwaiter().GetResult(); /// <summary> /// Executes an async Task<T> method which has a T return type synchronously /// USAGE: T result = AsyncUtil.RunSync(() => AsyncMethod<T>()); /// </summary> /// <typeparam name="TResult">Return Type</typeparam> /// <param name="task">Task<T> method to execute</param> /// <returns></returns> public static TResult RunSync<TResult>(Func<Task<TResult>> task) => TaskFactory.StartNew(task).Unwrap().GetAwaiter().GetResult(); } }</code></pre> Happy coding!2023-02-27T01:44:42.0000000Z

Blog post

The beauty of Decorator pattern in OptimizelyDecorator pattern is one of my favorite design pattern for backend code development. From wikipedia: A decorator pattern is a design pattern that allows a behavior to be added to an individual object dynamically, without affecting the behavior of other objects from the same classes. <img src="/link/61c8ea2655be4aa09b909b11ab10fcd4.aspx" /> Advantages:  <ul> <li>Helps you extend the behaviour of the classes/services without modifying the behavior. </li> <li>Helps enforcing single responsibility principle (one class one responsibility) and Open/Closed principle (classes can be extended but not modified). </li> <li>More efficient than subclassing because the objects behavior can be augmented without definining an entierly new object. </li> <li>Mainly used for caching keep the layer separate (including the keys can be made unique per functionality)</li> <li>Additional scenarios - logging, alerting, processing etc.</li> </ul> Implementation: A simple example is an alert needs to be sent every time an order is submitted or there's an unhandled exception in the order service after a user submits the order. It might be tempting to add an 'Alert Sender Email' dependency directly to the main order service class. However, if we need to stick to SRP and O/C SOLID principles, order service should only perform 1 job (submit the order).  In that case, one way to extend the behavior of the order service class is to create a new class that inherits from the same interface (IOrderSubmitService) that sends the email. This means you don't need to add a new interface (unlike sub-classing) which makes the interfaces slim and helps the interface segregation principle indirectly.  Sample code: <pre class="language-csharp"><code>namespace RF.Website.CMS.Features.CartCheckout.OrderSubmit.Alerting { using System; using System.Threading.Tasks; using RF.Website.CMS.Features.CartCheckout.OrderSubmit.Services; using RF.Website.CMS.Features.CartCheckout.OrderSubmit.ViewModels; using RF.Website.Common.Features.Foundation.Alerts.Services; public class AlertingOrderSubmitService : IOrderSubmitService { private readonly IOrderSubmitService _implementation; private readonly IAlertSender _alertSender; public AlertingOrderSubmitService( IOrderSubmitService orderSubmitService, IAlertSender alertSender) { _implementation = orderSubmitService ?? throw new ArgumentNullException(nameof(orderSubmitService)); _alertSender = alertSender ?? throw new ArgumentNullException(nameof(alertSender)); } public async Task<OrderSubmitViewModel> SubmitOrderAsync(string associateName, int cartVersion, string kountSessionId) { try { return await _implementation.SubmitOrderAsync(associateName, cartVersion, kountSessionId); // Potential to add code to send email after every successful submission. } catch (Exception exception) { string subject = "SubmitOrderAsync Error"; string body = "An error occurred while calling SubmitOrderAsync."; await _alertSender.SendAlertAsync(subject, body, exception); throw; } } } }</code></pre> The statement in the try block is the one that calls the implementation of the submit order The IOrderSubmitService: <pre class="language-csharp"><code>namespace ClientName.CartCheckout.OrderSubmit.Services { using System.Threading.Tasks; using ClientName.CartCheckout.OrderSubmit.ViewModels; public interface IOrderSubmitService { Task<OrderSubmitViewModel> SubmitOrderAsync(); } }</code></pre> Next you will need to ensure the above code wraps the main code by using a decorator pattern. Luckily, it comes as a part of the Structure map and can be easily incorporate this in your code. <pre class="language-csharp"><code>public void ConfigureContainer(ServiceConfigurationContext context) { context.StructureMap().Configure(container => { container.For<IOrderSubmitService>().Use<DefaultOrderSubmitService>(); // Can be used for logging or extending other behaviors of the Submit Order service // container.For<IOrderSubmitService>().DecorateAllWith<LoggingOrderSubmitService>(); container.For<IOrderSubmitService>().DecorateAllWith<AlertingOrderSubmitService>(); } }</code></pre> That's it. Add a breakpoint in the AlertingOrderSubmitService to see it in action. Every time it will hit the wrapper/decorator class and then into your concrete implementation of the functionality. Happy coding!2023-02-26T23:21:43.0000000Z

Blog post

Sending Files to Amazon S3 storageI am sure you have been asked by clients to create a scheduled job that generates a report and sends it to third party system for further processing. One of our client asked us to generate a daily report of all the completed orders for further processing in Snowflake. We looked at multiple options, but one option that stood out was creating a scheduled job and storing these report/CSV files in Amazon's S3 storage (considering it was heavily used by the client).  The integration to Amazon's S3 was relatively simpler than I thought. <h2>Step 1: Keys/Credentials for S3 storage</h2> Once the client to generate the keys and the bucket and provide us with the following: <ul> <li>User Name</li> <li>Access Key ID</li> <li>Secret Access Key</li> </ul> <h2>Step 2: Install S3 Browser</h2> This tool allows you to browse all the buckets with the client's S3 storage. You need to use the above credentials to browse the reports generated and published to this bucket. URL: https://s3browser.com/download.aspx <img src="/link/344572b8fba648e082c39b624e20d11d.aspx" /> <h2>Step 2: Install the AWS S3 SDK</h2> <img src="/link/b7d8a299774c4c73a3ad2d31ff05eea1.aspx" /> <h2>Step 3: Code</h2> Add the required code to transfer CSV files to AWS S3 storage <pre class="language-csharp"><code>namespace ClientName.Orders.DailyOrders.Services { using System; using Amazon; using Amazon.S3; using Amazon.S3.Transfer; public static class AmazonUploaderService { public static bool SendMyFileToS3(System.IO.Stream fileStream, string fileNameInS3) { try { var client = new AmazonS3Client(Amazon.RegionEndpoint.USEast1); // create a TransferUtility instance passing it the IAmazonS3 created in the first step TransferUtility utility = new TransferUtility(client); // making a TransferUtilityUploadRequest instance TransferUtilityUploadRequest request = new TransferUtilityUploadRequest(); request.BucketName = System.Configuration.ConfigurationManager.AppSettings["AWSBucketName"]; request.Key = fileNameInS3; request.InputStream = fileStream; utility.Upload(request); } catch (Exception ex) { return false; } return true; // indicate that the file was sent } } }</code></pre> Call the above function using the following code. <pre class="language-csharp"><code>_s3FileName = $"{DateTime.UtcNow.ToString("yyyy-MM-dd-hh-mm-ss")}-Snowflake-W2-orders.csv"; StringBuilder _report = "Col1, Col2, Col3, Col4..."; // List of all orders using string builder if (!string.IsNullOrWhiteSpace(_report?.ToString())) { byte[] byteArray = Encoding.ASCII.GetBytes(_report.ToString()); using (MemoryStream memoryStream = new MemoryStream(byteArray)) { uploaded = AmazonUploaderService.SendMyFileToS3(memoryStream, _s3FileName); } }</code></pre> <h2>Step 4: Test using S3 Browser</h2> Once the code is run successfully you should be able to view a list of all the reports generated using S3 browser you installed in step 2. That's it! Happy coding :)2023-02-25T00:40:35.0000000Z

Blog post

Alexa skill integration with Episerver - Part 1We all know Episerver is a very powerful Enterprise CMS. The content authors and marketers have complete control over content, personalization, analytics as well as access to user data at their finget tips.  With that said, the technological landscape is changing and so is user interaction with new innovative devices. In my opinion, websites (including responsive mobile websites) will always be the most popular way for presenting information, but as developers & marketers we should be prepared for this giant wave of new trend heading our way. Example: "50% of all searches will be voice searches by 2020". Episerver is prepared with it's Headless API to allow developers and marketers to ride the wave with ease. Episerver headless API allows serving same content to various devices including voice devices, mobile apps and others.   I recently implemented an Alexa skill that queries Episerver CMS and returns meaningful data to Alexa device. Though this is a very basic version/proof-of-concept for an Alexa skill it opens up a whole lot of possibilites depending on your user's interaction with the website. The Alexa skill I implemented reads out the two latest news or events from a website. This can very well be extended to "Give me the store locations for XYZ near Boston", "Are there any new promotions for ABC?", "Company's profit summary for this quarter". You get the point :)  As an end user, if you can get quick information from your favorite brand without having to spend time searching for it on a website, it's a huge value add in terms of convienience and saved time. No more booting up a device, navigating to a website, typing in a search box, enduring frustrating UI and performance issues. Simply ask "Alexa" what you need and listen to it while getting ready to go to work or during commercials on TV. If you are a technology (or tech savvy) organization it's even more important to display innovation to let your users know that you always "keep up" with new trends in technology. Alexa Skill: The core Alexa concept is pretty simple. It consists of: <ol> <li>Alexa skill kit (Front-end code) - <a href="https://developer.amazon.com/alexa/console/ask">https://developer.amazon.com/alexa/console/ask</a> </li> <li>Lambda function (Back-end code) - <a href="https://aws.amazon.com/lambda/">https://aws.amazon.com/lambda/</a> </li> </ol> You will need to setup 2 accounts: <ol> <li>Amazon Developer account (to configure front end interactions using Amazon provided UI)</li> <li>AWS account (to host the back end code called lambda function)</li> </ol> NOTE: Amazon Developer Account has a BETA feature that allows you to host the skill and the code in the same interface which is a super convinient and easy to understand. This is highly recommed if you want to get your Alexa skill up and running in minutes. When you create a new skill select the option "Alexa Hosted (Beta)" and you should be able to host and update the code in the same Amazon developer account.   Definitions: Skill Name: The name of the skill that will be used when you publish your skill to Amazon. Invocation Name: The term user will call out to invoke/start interaction with your skill. For ex: If the invocation name is "Fun Demo" the user can say Alexa open "Fun Demo" or Alexa start "Fun Demo" Intent: Intents allow you to specify what a user will say to invoke the skill. For ex: Get me the latest news or find me the closest stores in Boston area. You can create a custom intent as well as update the out-of-the-box Amazon provided Intents (such as CancelIntent or HelpIntent). Slots: Slots are nothing but parameters you can pass to the Intent to allow dynamic terms. For example: Order me {number} {size} pizza. The terms number and size are two dymamic parameters passed to the Intent. Endpoint: Endpoint is to connect your front end code (Invocation, Intents) to the backend code. If you are using Alexa hosted beta feaure, then no configuration is necessary. If the back end code is self-hosted (or a rest end point) these values need to be configured. The end point can be a REST endpoint which returns valid data or a lambda function that hosts your backend code.  To get started, as a first step I recommend setting up a simple Web API REST endpoint in Episerver that returns a JSON object. Ideally you would want to setup Episerver Headless API but for a quick demo a simple REST endpoint should be enough. I will get into the details of Alexa skill implementation and integrating it with Episerver in my next blog post. Stay tuned!2019-03-05T20:38:25.0000000Z

Blog post

Max & Min element validation for Content Area or Link CollectionReccently we had a business requirement for setting minimum & maximum limit for blocks in Content Areas. While we can educate the content authors to set the correct number of blocks in the content area it's always recommended to add validation within the CMS to avoid human errors. Here's the code to to set the maximum number of blocks in the content area and Link Item Collection.  <pre class="language-html"><code>/// <summary> /// Sets the maximum element count in a linkcollection, a content area - or any other type of collection. /// </summary> [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)] public class MaxElementsAttribute : ValidationAttribute, IMetadataAware { public int MaxCount { get; set; } public void OnMetadataCreated(ModelMetadata metadata) { //TODO: Use to disable editor drag and drop at a certain point. } protected override ValidationResult IsValid(object value, ValidationContext validationContext) { if (value == null) { return null; } if (value is LinkItemCollection) { if ((value as LinkItemCollection).Count > MaxCount) { return new ValidationResult("This field exceeds the maximum limit of " + MaxCount + " items"); } } else if (value is ContentArea) { if ((value as ContentArea).Count > MaxCount) { return new ValidationResult("This field exceeds the maximum limit of " + MaxCount + " items"); } } return null; } public MaxElementsAttribute(int MaxElementsInList) { this.MaxCount = MaxElementsInList; } }</code></pre> On the Content Area field (or Link Item Collection) set the MaxElements attribute as shown below.  <pre class="language-html"><code>[Display( Name = "Items", Description = "Items", GroupName = SystemTabNames.Content, Order = 30)] [MaxElements(25)] public virtual ContentArea Items { get; set; }</code></pre> You can use the same logic for setting the minimum number of elements as well.  Happy coding :)2018-10-07T04:35:21.0000000Z

Blog post

Boston's Episerver Developer/Editor meetup<!DOCTYPE html> <html> <head> </head> <body> Join us on Tuesday, June 12th 2018 from 5:30 - 7:30 pm for the first Episerver Developer/Editor Meetup in Boston hosted by Rightpoint. Speakers include <a href="https://www.linkedin.com/in/robfolan/">Rob Folan</a> from <a href="http://www.episerver.com/">Episerver</a> & <a href="https://www.linkedin.com/in/aniketdgadre/">myself</a> from <a href="https://www.rightpoint.com/">Rightpoint</a>. Rob will talk about the cool refreshing summer updates with the Episerver platform (Insight, Perform, Advance & Campain) and I will talk about the hot Digital Experience Cloud. To continue with the theme, we will be serving HOT pizza and COLD beverages. For more information and to RSVP, please visit the Eventbrite page <a href="https://www.eventbrite.com/e/episerver-developer-editor-boston-summer-meetup-tickets-45780188777">here</a>. Hope to see you all there! </body> </html>2018-05-29T22:26:41.0000000Z

Blog post

Dynamic Drop down list editable by content authors using ISelectionFactory & Property List<!DOCTYPE html> <html> <head> </head> <body> On one of my recent projects, we wanted the ability for content authors to manage a list of items in the dropdown through the CMS. Though, it's simple to create a list of items that can be retrieved from a constants class or an appsetting.config, it does require developer to make that change. This also means there needs to be a deployment to production for a simple name/value change in a dropdown. To get around this standard implementation, we implemented a simple Property List on the Start Page and referenced the property in the ISelectionFactory implementation to get the key value pair. The dropdown list can now be managed by the content authors without relying on the developer to make a change.   Here's the code: <pre class="language-html"><code> public class AccountPropertiesFactory : ISelectionFactory { public IEnumerable<ISelectItem> GetSelections(ExtendedMetadata metadata) { var contentRepository = ServiceLocator.Current.GetInstance<IContentLoader>(); var startPage = contentRepository.Get<StartPage>(ContentReference.StartPage); var selectItems = new List<SelectItem>(); foreach(var accountProperty in startPage.AccountTypePropertyList) { selectItems.Add( new SelectItem() { Text = accountProperty.Text, Value = accountProperty.Text } ); } return selectItems.ToArray(); } }</code></pre> </body> </html>2018-04-27T16:00:51.0000000Z

Blog post

Continuous Integration & Deployment with VSTS & DXC (Azure Integration environment)<!DOCTYPE html> <html> <head> </head> <body> I recently implemented continous integration & deployment using Visual Studio Team Services in Epi's DXC environment. Though I now feel it's pretty simple, it can be a little tricky if you have no prior experience configuring it. <h2>What is CI/CD?</h2> For folks who are new to build & deployment process, Continuous Integration (CI) is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early. Because you’re integrating so frequently, there is significantly less back-tracking to discover where things went wrong, so you can spend more time building features. Continuous Deployment (CD) is an extension of CI, where you can auto-deploy your integrated changes to the server (Integration environment in case of DXC). This significantly reduces the risks, costs and effort to deploy and allows you to deliver features to the clients sooner. <h2>Publish Profile:</h2> One important thing you need to get your head wrapped around is the concept of Publish Profile. If you are using Epi DXC service, you have azure portal access to the Integration environment (<a href="https://portal.azure.com">https://portal.azure.com</a>). If you don't, you should ask Episerver managed services to give you the access you need. The publish profile allows you to publish your code to Azure/Integration environment from Visual Studio (by setting up publishing profile) or VSTS (by adding it to the build definition). I prefer using VSTS since there are a lot more configuration options avaialable to you.      Here's how you download the publishing profile from Azure (Integration environment). App Services (left menu) > Select your App Service. You should see the "Get publish profile" button in your rightmost pane. <img src="/link/8326df1d6cda47279d2412fc96f022e3.aspx" alt="Image PublishProfile.GIF" />  You will need this in order to integrate with VSTS for CI/CD.  <h2>Buid Definition:</h2> VSTS allows you to setup multiple build definitions. You can have one build definition called "Develop CI" (that builds the develop branch) & one for "Integration CI/CD" (that builds & also deploys the code from the master branch). By separating out these build definitions, you can make sure that only master branch code (that is final) gets auto-deployed to the the Integration environment.  <img src="/link/427d0c62540b46cda6e6c84f53d0a7cd.aspx" width="664" alt="Image Build-Definition-3.GIF" height="332" /> For integration deployment under MSBuild Arguments you can provide details using the publishing profile you downloaded from Azure Integration environmnent. This will publish your changes after successfully building the "master" branch. If you see the "Get Sources" points to the master branch v/s develop branch as shown above. <img src="/link/52062711434a4493950a4312a1dfae35.aspx" width="1362" alt="Image Integration-Build-Definition.GIF" height="472" /> You can also setup triggers to run a build on every check-in (or scheduled) for the master branch, so when someone (hopefully a team lead/architect) pushes to the mater branch VSTS builds the solution (including nuget, gulp processes) and publishes your changes to the Integration environment without any manual intervention. This is just a basic process to setup CI/CD in the DXC environment. You can get get more creative with a lot of in-built features from VSTS. Hope this helps! Comments are welcome... AG  </body> </html>2017-04-04T21:03:31.7770000Z

Blog post

Episerver Certification - Tips & Tricks!!!<!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <meta name="author" content="Aniket Gadre" /> <meta name="description" content="Episerver certification, exam tips, tips and tricks" /> <meta name="keywords" content="Episerver Certification, exam tips, episerver cms, CMS, Episerver exam" /> <meta property="og:title" content="Episerver Certification - Tips & Tricks!" /> <meta property="”og:image”" content="http://cdn.certmag.com/wp-content/uploads/2015/07/Passed-the-exam-300x202.jpg" alt="Image result for exam you passed" /> <title>Episerver Certification - Tips & Tricks!</title> </head> <body> Yesterday, I passed the Episerver 9 Certifcation, so sharing my thoughts while it's fresh in my mind. <img src="http://cdn.certmag.com/wp-content/uploads/2015/07/Passed-the-exam-300x202.jpg" alt="Image result for exam you passed" /> <h2>Preparation:</h2> <ul> <li>If you have attended "Bootcamp", make sure you know the materials covered in the class inside out. This is your bible for the exam. I would say, at least 30-40% of the exam questions will be based on the material covered during the course. About 30-40% will be based on your understanding of these concepts. The rest of the questions can be based on admin, editor guides, SDK or sample Alloy website.</li> <li>Alloy, Alloy, Alloy. Did I mention the Alloy website? Look at every single method and class (if it doesn't make sense, google is your friend).</li> <li>Have at least one or two projects under your belt. To give you an anology - it's the difference between reading a book on swimming and actually swimming in the water.</li> <li>Understand all areas of CMS like editing interface, gadgets, mirroring, personalization, multi-site setup, languages, friendly urls, access rights, scheduled jobs etc. by clicking on each link and/or reading the admin/editor guides. </li> <li>Know all areas of development like CRUD operations on blocks/pages, templates, caching, modules, add ons, filtering, all base classes & APIs, localization, attributes, custom editor, dynamic data etc.</li> <li>Focus on the concepts. Ask yourself two questions - "How does it work" & "Why does it work that way". </li> </ul> <h2>About the Exam:</h2> Knowledge areas you will be tested on: <ul> <li>Production knowledge</li> <li>Installation</li> <li>Content Model</li> <li>Creating Websites</li> <li>Advanced Concepts</li> </ul> It's a multiple choice exam with 64 questions and 120 mins, so roughly 2 mins per question. I don't think time is an issue because I completed mine 45 mins before time. One tip I would like to give is, if you aren't confident about something, skip the quetsion and come back to it later. You can't go back once you have answered a question. There are 3 types of multiple choice questions: <ol> <li>Select ONE of the following 4 options.</li> <li>Select TWO of the following 4 options.</li> <li>Which of these is NOT true of the 4 options.</li> </ol> The last two are a little tricky because if you answer one out of the two wrong, your answer will be marked as incorrect. Be careful becuase the options are a little tricky :)  <h2>Before Exam (Remote):</h2> <ul> <li>You will receive an email from Episerver about the instructions 24-48 hours before the exam. Make sure you read these instructions carefully. This is a closed book (application) exam, so make sure you have nothing around you (including cell phones) and close all your applications. No multiple screens allowed during the exam.</li> <li>Book a quite conference room with a good internet connection (preferably wired). </li> <li>For remote exam, make sure your computer/laptop is compatible based on the instructions provided. This includes web camera, microphone, operating system etc.</li> <li>I would recommend you take the practice test (included in the instructions), so you are familair with the remote proctoring software and not figuring it out during the exam.</li> </ul> <h2>During Exam:</h2> <ul> <li>Keep your cool and don't rush. Some of the questions are difficult so you may have to wing it at the end. But you will get enough easy/medium level questions to pass the exam. </li> <li>Use some educated guesses. As long as you know the concepts on "How" and "Why" it will be easy for you to pick the right answer based on what you know.</li> <li>Don't leave the room or talk to anyone and avoid any distractions. </li> </ul> <h2>After Exam:</h2> You will receive a PASS or FAIL right after you complete the exam. If you passed the exam, you will receive an official email from Episerver after reviewing your recording within 5 working days. If you fail, you will be able to re-take the exam after 21 days.  Hope this helps, if you have any questions reach out to me on <a href="mailto:agadre@rightpoint.com">agadre@rightpoint.com</a> Good luck! AG </body> </html>2017-03-24T15:48:49.6330000Z

Blog post