public void Should_AbleToSetUrl(string url)
        {
            string name    = "MIT";
            var    license = new LicenseBuilder(name).Url(url).Build();

            Assert.Equal(url, license.Url);
        }
Esempio n. 2
0
        public License ToSDKLicense()
        {
            if (sdkLicense != null)
            {
                return(sdkLicense);
            }
            else if (apiLicense != null)
            {
                LicenseBuilder builder = LicenseBuilder.NewLicense()
                                         .CreatedOn(apiLicense.Created)
                                         .WithStatus(apiLicense.Status)
                                         .WithPaidUntil(apiLicense.PaidUntil)
                                         .WithPlan(new PlanConverter(apiLicense.Plan).ToSDKPlan());
                foreach (API.Transaction apiTransaction in apiLicense.Transactions)
                {
                    builder.WithTransaction(new TransactionConverter(apiTransaction).ToSDKTransaction());
                }

                return(builder.Build());
            }
            else
            {
                return(null);
            }
        }
Esempio n. 3
0
        public void Should_AbleToSetLicense()
        {
            string title              = "title";
            string version            = "1.0";
            var    license            = new License();
            var    licenseWithBuilder = new LicenseBuilder("name").Build();

            var info            = new InfoBuilder(title, version).License(license).Build();
            var infoWithBuilder = new InfoBuilder(title, version).License(licenseWithBuilder).Build();

            Assert.Equal(title, info.Title);
            Assert.Equal(version, info.Version);
            Assert.Equal(license, info.License);
            Assert.Equal(licenseWithBuilder, infoWithBuilder.License);
        }
Esempio n. 4
0
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Conventions.Remove <PluralizingTableNameConvention>();
            modelBuilder.Conventions.Add <OneToManyCascadeDeleteConvention>();
            var userBuilder                = new UserBuilder(modelBuilder.Entity <UserEntity>());
            var roleBuilder                = new RoleBuilder(modelBuilder.Entity <RoleEntity>());
            var companyBuilder             = new CompanyBuilder(modelBuilder.Entity <CompanyEntity>());
            var experimentBuilder          = new ExperimentBuilder(modelBuilder.Entity <ExperimentEntity>());
            var permissionBuilder          = new PermissionBuilder(modelBuilder.Entity <PermissionEntity>());
            var projectBuilder             = new ProjectBuilder(modelBuilder.Entity <ProjectEntity>());
            var auditTrailBuilder          = new AuditTrailBuilder(modelBuilder.Entity <AuditTrailEntity>());
            var auditTrailChangeLogBuilder = new AuditTrailChangeLogBuilder(modelBuilder.Entity <AuditTrailChangeLogEntity>());
            var LicenseTypeBuilder         = new LicenseTypeBuilder(modelBuilder.Entity <LicenseTypeEntity>());
            var LicenseBuilder             = new LicenseBuilder(modelBuilder.Entity <LicenseEntity>());
        }
Esempio n. 5
0
        public void withSpecifiedValues()
        {
            AccountBuilder accountBuilder = AccountBuilder.NewAccount()
                                            .WithName(ACC_NAME)
                                            .WithId(ACC_ID)
                                            .WithOwner(ACC_OWNER)
                                            .WithLogoUrl(ACC_LOGOURL)
                                            .WithData(ACC_DATA)
                                            .WithCompany(CompanyBuilder.NewCompany(ACC_CO_NAME)
                                                         .WithAddress(AddressBuilder.NewAddress()
                                                                      .WithAddress1(ACC_CO_ADDR_ADDR1)
                                                                      .WithAddress2(ACC_CO_ADDR_ADDR2)
                                                                      .WithCity(ACC_CO_ADDR_CITY)
                                                                      .WithCountry(ACC_CO_ADDR_COUNTRY)
                                                                      .WithState(ACC_CO_ADDR_STATE)
                                                                      .WithZipCode(ACC_CO_ADDR_ZIP).Build())
                                                         .WithId(ACC_CO_ID)
                                                         .WithData(ACC_CO_DATA)
                                                         .Build())
                                            .WithCustomField(CustomFieldBuilder.CustomFieldWithId(ACC_FIELD_ID)
                                                             .WithDefaultValue(ACC_FIELD_DEF_VLE)
                                                             .IsRequired(ACC_FIELD_IS_REQUIRED)
                                                             .WithTranslation(TranslationBuilder.NewTranslation(ACC_FIELD_TRANSL_LANG).Build())
                                                             .Build())
                                            .WithLicense(LicenseBuilder.NewLicense()
                                                         .CreatedOn(ACC_LIC_CREATED)
                                                         .WithPaidUntil(ACC_LIC_PAIDUNTIL)
                                                         .WithStatus(ACC_LIC_STATUS)
                                                         .WithTransaction(ACC_LIC_TRANS_CREATED,
                                                                          CreditCardBuilder.NewCreditCard()
                                                                          .WithCvv(ACC_LIC_TRANS_CC_CVV)
                                                                          .WithName(ACC_LIC_TRANS_CC_NAME)
                                                                          .WithNumber(ACC_LIC_TRANS_CC_NUM)
                                                                          .WithType(ACC_LIC_TRANS_CC_TYPE)
                                                                          .WithExpiration(ACC_LIC_TRANS_CC_EXP_MONTH, ACC_LIC_TRANS_CC_EXP_YEAR)
                                                                          .Build(),
                                                                          PriceBuilder.NewPrice()
                                                                          .WithAmount(ACC_LIC_TRANS_PRICE_AMOUNT)
                                                                          .WithCurrency(ACC_LIC_TRANS_PRICE_CURR_ID, ACC_LIC_TRANS_PRICE_CURR_NAME,
                                                                                        ACC_LIC_TRANS_PRICE_CURR_DATA)
                                                                          .Build())
                                                         .WithPlan(PlanBuilder.NewPlan(ACC_LIC_PLAN_ID)
                                                                   .WithId(ACC_LIC_PLAN_NAME)
                                                                   .WithContract(ACC_LIC_PLAN_CONTRACT)
                                                                   .WithDescription(ACC_LIC_PLAN_DES)
                                                                   .WithGroup(ACC_LIC_PLAN_GRP)
                                                                   .WithCycle(ACC_LIC_PLAN_CYC)
                                                                   .WithOriginal(ACC_LIC_PLAN_ORI)
                                                                   .WithData(ACC_LIC_PLAN_DATA)
                                                                   .WithFreeCycles(ACC_LIC_PLAN_CYC_COUNT, ACC_LIC_PLAN_CYC_CYCLE)
                                                                   .WithQuota(ACC_LIC_PLAN_QUOTA_CYCLE, ACC_LIC_PLAN_QUOTA_LIMIT, ACC_LIC_PLAN_QUOTA_SCOPE,
                                                                              ACC_LIC_PLAN_QUOTA_TARGET)
                                                                   .WithFeatures(ACC_LIC_PLAN_FEAT)
                                                                   .WithPrice(PriceBuilder.NewPrice()
                                                                              .WithAmount(ACC_LIC_PLAN_PRICE_AMOUNT)
                                                                              .WithCurrency(ACC_LIC_PLAN_PRICE_CURR_ID, ACC_LIC_PLAN_PRICE_CURR_NAME,
                                                                                            ACC_LIC_PLAN_PRICE_CURR_DATA)
                                                                              .Build())
                                                                   .Build())
                                                         .Build())
                                            .WithAccountProviders(new List <Provider>()
            {
                ProviderBuilder.NewProvider(ACC_PROV_DOC_NAME)
                .WithData(ACC_PROV_DOC_DATA)
                .WithId(ACC_PROV_DOC_ID)
                .WithProvides(ACC_PROV_DOC_NAME)
                .Build()
            }, new List <Provider>()
            {
                ProviderBuilder.NewProvider(ACC_PROV_USR_NAME)
                .WithData(ACC_PROV_USR_DATA)
                .WithId(ACC_PROV_USR_ID)
                .WithProvides(ACC_PROV_USR_PROVIDES)
                .Build()
            });

            Account account = accountBuilder.Build();

            Assert.AreEqual(ACC_NAME, account.Name);
            Assert.AreEqual(ACC_CO_ID, account.Company.Id);
            Assert.AreEqual(ACC_CO_ADDR_ADDR1, account.Company.Address.Address1);

            Assert.AreEqual(1, account.CustomFields.Count);
            Assert.AreEqual(ACC_FIELD_DEF_VLE, account.CustomFields[0].Value);
            Assert.AreEqual(1, account.CustomFields[0].Translations.Count);
            Assert.AreEqual(ACC_FIELD_TRANSL_LANG, account.CustomFields[0].Translations[0].Language);

            Assert.AreEqual(1, account.Licenses.Count);
            Assert.AreEqual(ACC_LIC_STATUS, account.Licenses[0].Status);
            Assert.AreEqual(1, account.Licenses[0].Transactions.Count);
            Assert.AreEqual(ACC_LIC_TRANS_CC_NUM, account.Licenses[0].Transactions[0].CreditCard.Number);
            Assert.AreEqual(ACC_LIC_TRANS_PRICE_AMOUNT, account.Licenses[0].Transactions[0].Price.Amount);
            Assert.AreEqual(ACC_LIC_PLAN_CONTRACT, account.Licenses[0].Plan.Contract);
            Assert.AreEqual(ACC_LIC_PLAN_PRICE_AMOUNT, account.Licenses[0].Plan.Price.Amount);

            Assert.AreEqual(1, account.Providers.Documents.Count);
            Assert.AreEqual(ACC_PROV_DOC_NAME, account.Providers.Documents[0].Name);
            Assert.AreEqual(1, account.Providers.Users.Count);
            Assert.AreEqual(ACC_PROV_USR_NAME, account.Providers.Users[0].Name);
        }