Example #1
0
        /// <summary>
        /// This method prepares the binary body for output from the content.
        /// </summary>
        /// <param name="context">The current context.</param>
        /// <param name="content">The content to be prepared.</param>
        /// <returns>Returns a ResourceManagerMessageFragmentBody object with the binary representation of the content.</returns>
        protected virtual ResourceManagerMessageFragmentBody PrepareBodyOutput(ResourceManagerContext context, BinaryContent content)
        {
            ResourceManagerMessageFragmentBody
                body = context.GetObjectPool<ResourceManagerMessageFragmentBody>().Get();

            byte[] blob = content.ToArray();

            switch (context.Request.Data.RequestPreferredCompression)
            {
                case "gzip":
                    using (MemoryStream ms = new MemoryStream())
                    {
                        using (Stream gz = new GZipStream(ms, CompressionMode.Compress, true))
                        {
                            gz.Write(blob, 0, blob.Length);
                            gz.Close();
                        }
                        ms.Position = 0;
                        body.Load(ms);
                    }
                    body.ContentEncoding = "gzip";
                    break;
                case "deflate":
                    using (MemoryStream ms = new MemoryStream())
                    {
                        using (Stream gz = new DeflateStream(ms, CompressionMode.Compress, true))
                        {
                            gz.Write(blob, 0, blob.Length);
                            gz.Close();
                        }
                        ms.Position = 0;
                        body.Load(ms);
                    }
                    body.ContentEncoding = "deflate";
                    break;
                default:
                    body.Load(blob, 0, blob.Length);
                    break;
            }

            blob = null;

            if (content.MimeType == null || content.MimeType == "")
            {
                if (context.Request.Settings.OutputColl.Count > 0)
                    body.ContentType = context.Request.Settings.OutputColl[0].OutputMIMEType;
                else
                    body.ContentType = "application/octet-stream";
            }
            else
                body.ContentType = content.MimeType;

            return body;
        }
        public override bool RequestValidate(ResourceManagerContext context)
        {
            Guid? cid = context.Request.ETagFlushID;
            if (cid.HasValue && context.ContextSettings.ETagCacheFlush(cid.Value))
            {
                context.Response.Status = CH.HTTPCodes.OK_200;
            }
            else
                context.Response.Status = CH.HTTPCodes.NotFound_404;

            return false;
        }
Example #3
0
        public static async Task SeedEssentialDataAsync
        (
            ResourceManagerContext context,
            UserManager <Worker> userManager,
            RoleManager <IdentityRole> roleManager,
            string adminPassword
        )
        {
            await SeedRolesAsync(roleManager);
            await CreateAdmin(userManager, adminPassword);

            await context.SaveChangesAsync();
        }
        /// <summary>
        /// This method determines whether the entity has not been modified, and if so
        /// simply instructs the calling party that that is the case.
        /// </summary>
        /// <param name="context">The current context.</param>
        /// <returns>Returns false if the output logic should not be processed.</returns>
        public override bool RequestValidate(ResourceManagerContext context)
        {
            //Check whether the request has an ETag.
            string ETag = context.Request.Data.RequestIfNoneMatch;
            context.CheckChangeState("OutputSelector");

            if (ETag == null || ETag == "")
                return true;

            try
            {
                Guid vid = new Guid(ETag.Trim(new char[] { '"' }));
                Guid? cid;
                DateTime? expiry;
                Type contentType;


                if (!context.ContextSettings.ETagValidate(vid, out cid, out expiry, out contentType))
                    return true;


                if (expiry.HasValue && expiry.Value > DateTime.Now)
                {
                    context.Request.Data.ResponseHeaderAdd("Expires", CH.ConvertToRFC1123DateString(expiry.Value));
                    //set the cache control to public as we want these resources to be as cached as possible.
                    context.Request.Data.ResponseHeaderAdd("Cache-control", "public");
                }
                else if (!RevalidateAndUpdateETag(context, vid, cid.Value, contentType)) //OK, check the CDS to see if the content has changed.
                {
                    context.Request.Data.ResponseHeaderAdd("X-debug", "cachehit revalidate fail");

                    return true;
                }
                else
                    context.Request.Data.ResponseHeaderAdd("Cache-control", "must-revalidate");

                context.Request.Data.ResponseHeaderAdd("ETag", ETag);
        
                context.Response.Status = CH.HTTPCodes.NotModified_304;
                context.Response.Substatus = "Not Modified";
                return false;
            }
            catch (Exception ex)
            {
                context.Request.Data.ResponseHeaderAdd("X-debug", "cachehit exception");
                return true;
            }
        }
Example #5
0
        /// <summary>
        /// This is the initialize state. This method does nothing.
        /// </summary>
        /// <param name="context">The current context.</param>
        public override void Initialize(ResourceManagerContext context)
        {
            string subCommand = "";

            if (context.Data.DestinationAddress.SubCommand is string)
                subCommand =(string)context.Data.DestinationAddress.SubCommand;

            switch (subCommand)
            {
                case "ETagFlush":
                    context.CheckChangeState("ETagCacheFlush");
                    break;
                default:
                    context.CheckChangeState("OutputSelector");
                    break;
            }
        }
        /// <summary>
        /// This method selects the appropriate node and creates a Body content.
        /// </summary>
        /// <param name="context">The current context.</param>
        public override void OutputPrepare(ResourceManagerContext context)
        {
            BinaryContent content = null;
            try
            {
                Uri resource = new Uri(context.Request.Settings.OutputColl[0].Output);

                GuidHolder holder;
                lock (syncLockCache)
                {
                    byte[] blob;
                    if (!mInternalResourceCache.ContainsKey(resource))
                    {
                        blob = RH.ResourceLoadFromUri(resource);
                        holder = new GuidHolder(Guid.NewGuid(), Guid.NewGuid(), blob);
                        mInternalResourceCache.Add(resource, holder);
                    }
                    else
                        holder = mInternalResourceCache[resource];
                }

                content = context.GetObjectPool<BinaryContent>().Get();
                content.Load();
                content.Data = holder.blob;
                //content.Load(holder.blob, 0, holder.blob.Length);
                content.IDContent = holder.ID;
                content.IDVersion = holder.Version;

                string statusBody;
                context.Response.Body = PrepareBody(context, content, out statusBody);
                context.Response.Status = statusBody;
            }
            catch (Exception ex)
            {
                context.Response.Body = null;
                context.Response.Status = CH.HTTPCodes.InternalServerError_500;
                context.Response.Substatus = ex.Message;
            }
            finally
            {
                if (content != null && content.ObjectPoolCanReturn)
                    content.ObjectPoolReturn();
                content = null;
            }
        }
Example #7
0
        /// <summary>
        /// This method selects the appropriate node and creates a Body content.
        /// </summary>
        /// <param name="context">The current context.</param>
        public override void OutputPrepare(ResourceManagerContext context)
        {
            Content content = null;
            try
            {
                string refType = "name";// context.Request.Data.VariableGet("resourcetype");
                string refValue = context.Request.Data.VariableGet("resourcevalue");

                Type entityType = RH.CreateTypeFromString(context.Request.Settings.OutputColl[0].Output);

                string status;
                throw new NotImplementedException();
                //= context.CDSHelper.Execute(entityType, 
                //    CDSData.Get(CDSAction.Read, refType, refValue)
                //    , out content);

                if (status == CH.HTTPCodes.OK_200 && content is BinaryContent)
                {
                    string statusBody;
                    context.Response.Body = PrepareBody(context, (BinaryContent)content, out statusBody);
                    context.Response.Status = statusBody;
                }
                else
                {
                    context.Response.Body = null;
                    context.Response.Status = CH.HTTPCodes.NotFound_404;
                }
            }
            catch (Exception ex)
            {
                context.Response.Body = null;
                context.Response.Status = CH.HTTPCodes.InternalServerError_500;
                context.Response.Substatus = ex.Message;
            }
            finally
            {
                if (content != null && content.ObjectPoolCanReturn)
                    content.ObjectPoolReturn();
                content = null;
            }
        }
 /// <summary>
 /// This method selects the appropriate output style.
 /// </summary>
 /// <param name="context">The current context.</param>
 public override void OutputSelect(ResourceManagerContext context)
 {
     string id = context.Request.Settings.OutputColl[0].OutputType;
     switch (id)
     {
         case "file":
             context.CheckChangeState("RS_OutputFile");
             break;
         case "resource":
             context.CheckChangeState("RS_OutputResource");
             break;
         case "cds":
             context.CheckChangeState("RS_OutputCDS");
             break;
         //case "app":
         //    context.CheckChangeState("RS_OutputAPP");
         //    break;
         default:
             throw new InvalidOutputCCException(@"Output format """ + id + @""" not recognised.");
     }
 }
 public virtual bool RequestValidate(ResourceManagerContext context)
 {
     throw new NotImplementedException("ContentCompilerState->RequestValidate is not implemented: " + this.ToString());
 }
Example #10
0
 public override void OutputComplete(ResourceManagerContext context)
 {
     //Do nothing
 }
Example #11
0
 public WorkerRepository(ResourceManagerContext context) : base(context)
 {
 }
 public SupplierRepository(ResourceManagerContext context) : base(context)
 {
 }
 public SafetyClassRepository(ResourceManagerContext context) : base(context)
 {
 }
 public DistrictRepository(ResourceManagerContext context) : base(context)
 {
 }
Example #15
0
 public BaseRepository(ResourceManagerContext context)
 {
     this.Context = context;
 }
Example #16
0
        /// <summary>
        /// This method prepares the HTTP body based on the browser content encoding settings.
        /// </summary>
        /// <param name="context">The current compile context.</param>
        /// <param name="blob">The UTF-8 formatted byte array.</param>
        /// <returns>Returns a ContentCompilerMessageFragmentBody object containing the prepared output binary data.</returns>
        protected virtual ResourceManagerMessageFragmentBody PrepareBody(
            ResourceManagerContext context, BinaryContent content, out string status)
        {
            DateTime? expiry = null;

            string cacheControl = context.Request.Data.RequestHeaderGet("Cache-Control");
            bool allowNotModified = cacheControl == null || cacheControl.ToLowerInvariant() != "no-cache";

            
            int? expiryIns = content.CacheExpiry;
            ResourceManagerMessageFragmentBody body = null;

            string eTag = content.IDVersion.ToString("N").ToUpperInvariant();
            string eTagValidate = context.Request.Data.RequestIfNoneMatch.Trim(new char[]{'"',' '});

            if ((content.CacheOptions & ContentCacheOptions.Cacheable)>0)
                expiry = DateTime.Now.AddSeconds(expiryIns.Value);

            context.ContextSettings.ETagAdd(content.IDVersion, content.IDContent, expiry, content.GetType(), expiryIns);

            //Next check whether we have an etag in the request, and whether it matches the content.
            if (!allowNotModified || eTagValidate == "" || eTag != eTagValidate)
            {
                //Ok, get the body.
                body = PrepareBodyOutput(context, content);

                body.ETag = string.Format(@"""{0}""", eTag);
                if (expiry.HasValue)
                    body.Expires = CH.ConvertToRFC1123DateString(expiry.Value);

                status = CH.HTTPCodes.OK_200;
            }
            else
            {
                if (expiry.HasValue)
                    context.Request.Data.ResponseHeaderAdd("Expires", CH.ConvertToRFC1123DateString(expiry.Value));
                context.Request.Data.ResponseHeaderAdd("ETag", string.Format(@"""{0}""", eTag));

                status = CH.HTTPCodes.NotModified_304;
            }

            if (expiry.HasValue)
                context.Request.Data.ResponseHeaderAdd("Cache-control", "public");
            else if ((content.CacheOptions & ContentCacheOptions.VersionCheck) > 0)
                context.Request.Data.ResponseHeaderAdd("Cache-control", "must-revalidate");

            return body;
        }
Example #17
0
 public OrderStatusRepository(ResourceManagerContext context) : base(context)
 {
 }
Example #18
0
 public InventoryGivingStatusRepository(ResourceManagerContext context) : base(context)
 {
 }
 public InventoryRepository(ResourceManagerContext context) : base(context)
 {
 }
 public MeasuringUnitRepository(ResourceManagerContext context) : base(context)
 {
 }
Example #21
0
 public OrderItemRepository(ResourceManagerContext context) : base(context)
 {
 }
 public ResourceSubCategoryRepository(ResourceManagerContext context) : base(context)
 {
 }
 public virtual void Finish(ResourceManagerContext context)
 {
     throw new NotImplementedException("ContentCompilerState->Finalize is not implemented " + this.ToString());
 }
 public EcologyClassRepository(ResourceManagerContext context) : base(context)
 {
 }
 public virtual void OutputComplete(ResourceManagerContext context)
 {
     throw new NotImplementedException("ContentCompilerState->OutputPrepare is not implemented: " + this.ToString());
 }
        /// <summary>
        /// This method revalidates the etag versionID values with the Content Data Store. 
        /// This method also resets the content expiry time, or removes the ETag from the cache if the version is invalid.
        /// </summary>
        /// <param name="context">The current context.</param>
        /// <param name="vidIn">The Etag version ID.</param>
        /// <param name="cidIn">The content ID.</param>
        /// <param name="contentType">The content type.</param>
        /// <returns>Returns true if the ETag is valid.</returns>
        protected virtual bool RevalidateAndUpdateETag(ResourceManagerContext context,
            Guid vidIn, Guid cidIn, Type contentType)
        {
            Guid? cid, vid;
            throw new NotImplementedException();
            string status;
            //= context.CDSHelper.Execute(contentType,
            //    CDSData.Get(CDSAction.VersionCheck, cidIn, null), out cid, out vid);

            if (status != CH.HTTPCodes.OK_200)
                return false;

            bool success = vidIn == vid;

            if (success)
                context.ContextSettings.ETagExpiryReset(vidIn);
            else
                context.ContextSettings.ETagCacheFlush(cidIn);

            return success;
        }
Example #27
0
 public CityRepository(ResourceManagerContext context) : base(context)
 {
 }
 public WarehouseRepository(ResourceManagerContext context) : base(context)
 {
 }
Example #29
0
        public override void Finish(ResourceManagerContext context)
        {

        }