public async Task <IHttpActionResult> GetFormStatus(
            Guid?periodComponentId,
            string organizationCode = null)
        {
            if (bfsConfig.Logging.TraceEnabled)
            {
                Configuration.Services.GetTraceWriter().Info(Request, "Контроллер " + GetType().Name, MethodBase.GetCurrentMethod().Name);
            }

            ReportPeriodComponent reportPeriodComponent = await _db.ReportPeriodComponents.Where(c => c.Id == periodComponentId).FirstOrDefaultAsync();

            ReportSubmitChain reportSubmitChain = await _db.ReportSubmitChains
                                                  .Where(c => c.Id == reportPeriodComponent.ReportSubmitChainId)
                                                  .Include(c => c.ChainElements)
                                                  .ThenInclude(e => e.Organization)
                                                  .FirstOrDefaultAsync();

            List <StoredFormData> storedFormData = await _db.StoredFormDatas
                                                   .Where(sd => !periodComponentId.HasValue || sd.ReportPeriodComponentId == periodComponentId)
                                                   .Where(sd => organizationCode == null || sd.Organization.Code == organizationCode)
                                                   .Include(sd => sd.Organization)
                                                   .ToListAsync();

            foreach (ReportSubmitChainElement chainElement in reportSubmitChain.ChainElements)
            {
                string metaFormCode = storedFormData.Count == 0 ? "" : storedFormData.FirstOrDefault().MetaFormCode;

                if (storedFormData.Where(s => s.OrganizationId == chainElement.OrganizationId).Count() == 0)
                {
                    storedFormData.Add(new StoredFormData()
                    {
                        StatusNumber       = 0,
                        Organization       = chainElement.Organization,
                        ExpertStatusNumber = 0,
                        ExternalConstraintsStatusNumber = 0,
                        InternalConstraintsStatusNumber = 0,
                        ReportPeriodComponent           = reportPeriodComponent,
                        ReportPeriodComponentId         = reportPeriodComponent.Id,
                        OrganizationId         = chainElement.OrganizationId,
                        SubmitChainElementType = chainElement.Type,
                        MetaFormCode           = metaFormCode,
                        Id = null,
                    });
                }
            }

            if (storedFormData == null)
            {
                return(NotFound());
            }

            return(Ok(storedFormData));
        }
        public async Task <IHttpActionResult> GetReportPeriodComponentByCode(
            Guid?periodId,
            string name = null,
            string code = null)
        {
            if (bfsConfig.Logging.TraceEnabled)
            {
                Configuration.Services.GetTraceWriter().Info(Request, "Контроллер " + GetType().Name, MethodBase.GetCurrentMethod().Name);
            }

            var request =
                _db.ReportPeriodComponents
                .Where(rpc => rpc.ReportPeriodId == periodId);

            if (code != null || name != null)
            {
                ReportPeriodComponent periodComponent =
                    await request
                    .Where(rpc => name == null || rpc.Name == name)
                    .Where(rpc => code == null || rpc.Code == code)
                    .Include(rpc => rpc.StoredFormData)
                    .Include(rpc => rpc.FormsBundle)
                    .Include(rpc => rpc.ReportPeriod)
                    .Include(rpc => rpc.ReportSubmitChain)
                    .FirstOrDefaultAsync();

                if (periodComponent != null)
                {
                    return(Ok(periodComponent));
                }
            }
            else
            {
                List <ReportPeriodComponent> periodComponents =
                    await request
                    .OrderBy(rpc => rpc.Code)
                    .ToListAsync();

                if (periodComponents != null)
                {
                    return(Ok(periodComponents));
                }
            }

            return(NotFound());
        }
        public async Task <IHttpActionResult> GetReportPeriodComponent(Guid id)
        {
            ReportPeriodComponent periodComponent =
                await _db.ReportPeriodComponents
                .Where(rpc => rpc.Id == id)
                .Include(rpc => rpc.StoredFormData)
                .ThenInclude(sf => sf.Organization)
                .Include(rpc => rpc.FormsBundle)
                .Include(rpc => rpc.ReportPeriod)
                .Include(rpc => rpc.ReportSubmitChain)
                .FirstOrDefaultAsync();

            if (periodComponent == null)
            {
                return(NotFound());
            }

            return(Ok(periodComponent));
        }