public ActionResult Index(RFDate?valueDate)
        {
            valueDate = valueDate ?? RFDate.Today();

            using (var activity = _activityFunc(Context, Username))
            {
                valueDate = activity.GetLatestDate(valueDate.Value);

                if (!valueDate.HasValue)
                {
                    return(Error(_errorRedirect.Action, _errorRedirect.Controller, new { area = _errorRedirect.Area }, "No Attributions found."));
                }
                else
                {
                    return(View(new AttributionModel
                    {
                        ValueDate = valueDate.Value,
                        RequiresApply = activity.RequiresApply(valueDate.Value),
                        AreaName = Request.RequestContext.RouteData.DataTokens["area"].ToString(),
                        ControllerName = ControllerContext.RouteData.Values["controller"].ToString(),
                        PresentationMode = IsPresentationMode()
                    }));
                }
            }
        }
        public JsonResult GetPreview(int mirroredFileID, int sectionNo = 0, int maxRows = 100)
        {
            using (var activity = new RFMirrorActivity(Context, Username))
            {
                var file = activity.GetFile(mirroredFileID);
                if (file.content != null)
                {
                    var report = RFReportParserProcessor.LoadFromStream(new System.IO.MemoryStream(file.content), new RFFileTrackedAttributes
                    {
                        FileName     = file.mirroredFile.FileName,
                        FileSize     = file.mirroredFile.FileSize,
                        FullPath     = file.mirroredFile.MirrorPath,
                        ModifiedDate = file.mirroredFile.ModifiedTime
                    }, RFDate.Today(), new RFReportParserConfig
                    {
                        Format     = RFReportParserFormat.AutoDetect,
                        HasHeaders = false
                    }, new RFSimpleReportBuilder());
                    if (report != null && report.Sections.Count > sectionNo)
                    {
                        var dataTable = report.Sections.Skip(sectionNo).First().AsDataTable();
                        if (dataTable != null)
                        {
                            dataTable.Columns["RFRowNo"].SetOrdinal(0);
                            dataTable.Columns["RFRowNo"].ColumnName = "#";
                            foreach (DataColumn c in dataTable.Columns)
                            {
                                if (Int32.TryParse(c.ColumnName, out var n))
                                {
                                    c.ColumnName = Interfaces.Formats.XLS.XLSGenerator.GetExcelColumnName(n + 1);
                                }
                            }
                            for (var i = dataTable.Rows.Count - 1; i >= maxRows; i--)
                            {
                                dataTable.Rows[i].Delete();
                            }
                        }

                        var sections = new List <object>();
                        int sn       = 0;
                        foreach (var s in report.Sections)
                        {
                            sections.Add(new { id = sn, name = $"[{sn + 1}] {s.Name}" });
                            sn++;
                        }

                        return(Json(new
                        {
                            sections = sections,
                            selectedSection = sectionNo,
                            preview = dataTable
                        }));
                    }
                }
                return(null);
            }
        }
 private static TestDocument CreateTestDocument()
 {
     return(new TestDocument
     {
         Decimal = 5.55M,
         Dict = new Dictionary <string, string> {
             { "Key1", "Value1" }, { "Key2", "Value2" }
         },
         IgnoreMe = 10,
         Int = 505,
         RFDate = RFDate.Today(),
         StringList = new List <string> {
             "S1", "S2", "S3 "
         }
     });
 }
        public void GraphDependencyTest()
        {
            var instance = new RFGraphInstance {
                Name = "default", ValueDate = RFDate.Today()
            };

            var s1Key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "S", TestEngine.TestKeys.Key1, instance);
            var s2Key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "S", TestEngine.TestKeys.Key2, instance);

            _fixture.Context.SaveDocument(s1Key, "S", true);
            _fixture.Context.SaveDocument(s2Key, "S", true);

            Thread.Sleep(2000);

            // results
            var e1Key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "E", TestEngine.TestKeys.Key1, instance);
            var e2Key = RFGenericCatalogKey.Create(_fixture.KeyDomain, "E", TestEngine.TestKeys.Key2, instance);

            // execution counts
            var a1Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "A_Counter", TestEngine.TestKeys.Key1, instance);
            var b1Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "B_Counter", TestEngine.TestKeys.Key1, instance);
            var c1Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "C_Counter", TestEngine.TestKeys.Key1, instance);
            var a2Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "A_Counter", TestEngine.TestKeys.Key2, instance);
            var b2Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "B_Counter", TestEngine.TestKeys.Key2, instance);
            var c2Count = RFGenericCatalogKey.Create(_fixture.KeyDomain, "C_Counter", TestEngine.TestKeys.Key2, instance);

            Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(a1Count));
            Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(b1Count));
            Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(c1Count));

            Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(a2Count));
            Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(b2Count));
            Assert.Equal(1, _fixture.Context.LoadDocumentContent <object>(c2Count));

            Assert.Equal("SASABC", _fixture.Context.LoadDocumentContent <string>(e1Key));
            Assert.Equal("SASABC", _fixture.Context.LoadDocumentContent <string>(e2Key));
        }
        public void KeyInstancesTest()
        {
            var key1 = RFGenericCatalogKey.Create(_fixture.KeyDomain, "KeyInstancesTest", TestEngine.TestKeys.Key1, new RFGraphInstance {
                Name = "dummy", ValueDate = RFDate.Today()
            });
            var key2 = RFGenericCatalogKey.Create(_fixture.KeyDomain, "KeyInstancesTest", TestEngine.TestKeys.Key2, new RFGraphInstance {
                Name = "dummy", ValueDate = RFDate.Today()
            });

            foreach (var date in RFDate.Range(new RFDate(2016, 7, 1), new RFDate(2016, 7, 12), d => true))
            {
                // 12 of these
                var key11 = key1.CreateForInstance(new RFGraphInstance
                {
                    Name      = "default1",
                    ValueDate = date
                });
                _fixture.Context.SaveDocument(key11, "Test", false);

                // 6 of these
                if (date.Day % 2 == 0)
                {
                    var key12 = key1.CreateForInstance(new RFGraphInstance
                    {
                        Name      = "default2",
                        ValueDate = date
                    });
                    _fixture.Context.SaveDocument(key12, "Test", false);
                }

                // 4 of these
                if (date.Day % 3 == 0)
                {
                    var key21 = key2.CreateForInstance(new RFGraphInstance
                    {
                        Name      = "default1",
                        ValueDate = date
                    });
                    _fixture.Context.SaveDocument(key21, "Test", false);
                }

                // 3 of these
                if (date.Day % 4 == 0)
                {
                    var key22 = key2.CreateForInstance(new RFGraphInstance
                    {
                        Name      = "default2",
                        ValueDate = date
                    });
                    _fixture.Context.SaveDocument(key22, "Test", false);
                }
            }

            _fixture.Context.SaveDocument(key2.CreateForInstance(null), "Test", false); // this should be ignored

            var keys1 = _fixture.Context.GetKeyInstances(key1);

            Assert.Equal(18, keys1.Count);
            Assert.Equal(12, keys1.Where(k => k.Value.GraphInstance.Name == "default1").Count());
            Assert.Equal(6, keys1.Where(k => k.Value.GraphInstance.Name == "default2").Count());

            var keys2 = _fixture.Context.GetKeyInstances(key2);

            Assert.Equal(7, keys2.Count);
            Assert.Equal(4, keys2.Where(k => k.Value.GraphInstance != null && k.Value.GraphInstance.Name == "default1").Count());
            Assert.Equal(3, keys2.Where(k => k.Value.GraphInstance != null && k.Value.GraphInstance.Name == "default2").Count());

            // invalidate
            _fixture.Context.Invalidate(key1.CreateForInstance(new RFGraphInstance
            {
                Name      = "default1",
                ValueDate = new RFDate(2016, 7, 12)
            }));

            // get latest
            var latest1 = _fixture.Context.LoadEntry(key1.CreateForInstance(new RFGraphInstance
            {
                Name      = "default1",
                ValueDate = RFDate.Today()
            }), new RFCatalogOptions
            {
                DateBehaviour = RFDateBehaviour.Latest
            });

            Assert.Equal(11, latest1.Key.GraphInstance.ValueDate.Value.Day);

            var latest2 = _fixture.Context.LoadEntry(key1.CreateForInstance(new RFGraphInstance
            {
                Name      = "default2",
                ValueDate = RFDate.Today()
            }), new RFCatalogOptions
            {
                DateBehaviour = RFDateBehaviour.Latest
            });

            Assert.Equal(12, latest2.Key.GraphInstance.ValueDate.Value.Day);
        }
        public ActionResult BackupMasterKey(string p)
        {
            try
            {
                var keys = new List <object>();
                RFLoginCache.Login(LoginUsername, p);
                // find all vaults
                var vaults = Context.GetKeysByType <RFKeyVaultKey>();
                var sb     = new StringBuilder();
                sb.AppendLine("VaultName,KeyID,Base64");
                if (vaults.Any())
                {
                    foreach (var vaultKey in vaults.Values)
                    {
                        using (var secure = new RFSecureActivity(Context, LoginUsername, new RFSimpleKeyDomain(vaultKey.Root), vaultKey.Enum))
                        {
                            var vault     = secure.OpenKeyVault(RFLoginCache.GetPasswordHash(LoginUsername));
                            var masterKey = vault.GetKey(RFKeyVault.MASTER_KEY_ID);
                            if (masterKey != null)
                            {
                                sb.AppendFormat("{0},{1},{2}{3}", vaultKey.Enum.ToString(), RFKeyVault.MASTER_KEY_ID, Convert.ToBase64String(masterKey), Environment.NewLine);
                            }
                        }
                    }
                }

                Context.UserLog.LogEntry(new RFUserLogEntry
                {
                    Action       = "BackupMasterKey",
                    Area         = "Encryption",
                    Description  = "Backed up Master Key.",
                    IsUserAction = true,
                    IsWarning    = false,
                    Username     = Username,
                    Timestamp    = DateTimeOffset.Now
                });

                return(File(System.Text.Encoding.ASCII.GetBytes(sb.ToString()), "text/csv", string.Format("Master Key Backup {0}.csv", RFDate.Today().ToString("yyyy-MM-dd"))));
            }
            catch (Exception ex)
            {
                return(Content("<html><body><h3>Error</h3><p>" + ex.Message + "</p></body></html>"));
            }
        }