public async Task GetPreviousSubmission_ReturnsPreviousSubmissionForSameSchemeOnly() { using (var database = new DatabaseWrapper()) { // Arrange DataReturnSubmissionsDataAccess dataAccess = new DataReturnSubmissionsDataAccess(database.WeeeContext); ModelHelper modelHelper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme1 = modelHelper.CreateScheme(); var dataReturnVersion = modelHelper.CreateDataReturnVersion(scheme1, 2015, 1, true); dataReturnVersion.SubmittedDate = new DateTime(2015, 1, 1); var dataReturnVersion2 = modelHelper.CreateDataReturnVersion(scheme1, 2015, 1, true); dataReturnVersion2.SubmittedDate = new DateTime(2015, 3, 1); var scheme2 = modelHelper.CreateScheme(); var dataReturnVersion3 = modelHelper.CreateDataReturnVersion(scheme2, 2015, 1, true); dataReturnVersion3.SubmittedDate = new DateTime(2015, 2, 1); database.Model.SaveChanges(); var domainDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion2.Id); // Act var result = await dataAccess.GetPreviousSubmission(domainDataReturnVersion); // Assert Assert.NotNull(result); Assert.Equal(dataReturnVersion.Id, result.Id); } }
public override bool TryFindContent(PublishedContentRequest docRequest) { string route = string.Empty; if (docRequest.HasDomain) { route = docRequest.Domain.RootNodeId.ToString() + DomainHelper.PathRelativeToDomain(docRequest.DomainUri, docRequest.Uri.GetAbsolutePathDecoded()); } else { route = docRequest.Uri.GetAbsolutePathDecoded(); } var node = FindContent(docRequest, route); string templateAlias = GetTemplateAliasByContentAccept(docRequest); ITemplate template = ApplicationContext.Current.Services.FileService.GetTemplate(templateAlias); if (template != null) { LogHelper.Debug <ContentFinderByNiceUrlWithContentAccept>("Valid template: \"{0}\"", () => templateAlias); if (node != null) { docRequest.SetTemplate(template); } } else { LogHelper.Debug <ContentFinderByNiceUrlWithContentAccept>("Not a valid template: \"{0}\"", () => templateAlias); } return(node != null); }
internal override void Execute(IDeleteCore core) { core.AddExcuteOperation(String.Format("Очищаем коллекции в {0}", DomainHelper.GetSubjectNames(RemoveInClassType).NominativePlural)); var collectionProp = RemoveInClassType.GetProperty(CollectionName); var removeMethod = String.IsNullOrEmpty(RemoveMethodName) ? null : RemoveInClassType.GetMethod(RemoveMethodName); foreach (var item in RemoveInItems) { logger.Debug("Удаляем {2} из коллекции {0} в {1}...", CollectionName, item.Title, RemovingEntity.Title); if (removeMethod != null) { if (item.Entity is IBusinessObject) { (item.Entity as IBusinessObject).UoW = core.UoW; } removeMethod.Invoke(item.Entity, new object[] { RemovingEntity.Entity }); } else { var collection = (IList)collectionProp.GetValue(item.Entity, null); collection.Remove(RemovingEntity.Entity); } core.UoW.TrySave(item.Entity); } }
public async Task HandleAsync_XmlContainsSchemaError_CreatesDataReturnUpload_WithNullComplianceYearAndQuarter() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var organisation = helper.CreateOrganisation(); helper.CreateScheme(organisation); database.Model.SaveChanges(); var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext); var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>( "Test XML string", A.Dummy<SchemeReturn>(), new List<XmlValidationError> { new XmlValidationError(ErrorLevel.Error, XmlErrorType.Schema, "Error text") }); A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._)) .Returns(xmlGeneratorResult); // Act var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id); // Assert var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId); Assert.Null(dataReturnUpload.ComplianceYear); Assert.Null(dataReturnUpload.Quarter); } }
protected virtual void DeleteEntities(TNode[] nodes) { foreach (var node in nodes) { DeleteEntityService.DeleteEntity <TEntity>(DomainHelper.GetId(node)); } }
public async Task HandleAsync_CreatesUserWithStandardUserRole() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var user = helper.GetOrCreateUser("TestUser"); user.Email = "*****@*****.**"; database.Model.SaveChanges(); var handler = new AddCompetentAuthorityUserHandler(database.WeeeContext, A.Dummy<ITestUserEmailDomains>()); // Act var competentAuthorityUserId = await handler.HandleAsync(new AddCompetentAuthorityUser(user.Id)); var competentAuthorityUser = domainHelper.GetCompetentAuthorityUser(competentAuthorityUserId); // Assert Assert.Equal(user.Id, competentAuthorityUser.UserId); Assert.NotNull(competentAuthorityUser.Role); Assert.Equal("InternalUser", competentAuthorityUser.Role.Name); } }
protected void Page_Load(object sender, EventArgs e) { this._domainName = String.Format(Settings.Default.SimpleDbDomainNameFormat, this.Context.User.Identity.Name); if (!this.Page.IsPostBack) { using (AmazonSimpleDBClient sdbClient = new AmazonSimpleDBClient(Amazon.RegionEndpoint.USWest2)) { DomainHelper.CheckForDomain(this._domainName, sdbClient); SelectRequest selectRequest = new SelectRequest() { SelectExpression = String.Format("select * from `{0}`", this._domainName) }; SelectResponse selectResponse = sdbClient.Select(selectRequest); List <Item> items = selectResponse.Items; List <Pet> pets = items.Select(l => new Pet { Id = l.Name, PhotoThumbUrl = l.Attributes.First(a => a.Name == "PhotoThumbUrl").Value, Name = l.Attributes.First(a => a.Name == "Name").Value, Birthdate = l.Attributes.First(a => a.Name == "Birthdate").Value, Sex = l.Attributes.First(a => a.Name == "Sex").Value, Type = l.Attributes.First(a => a.Name == "Type").Value, Breed = l.Attributes.First(a => a.Name == "Breed").Value }).ToList(); this.PetRepeater.DataSource = pets; this.PetRepeater.DataBind(); } } }
public static XPathNavigator GetOrder(string uniqueOrderId) { if (!string.IsNullOrEmpty(uniqueOrderId)) { //Log.Instance.LogDebug(DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt") + " XSLTExtensions.GetOrder >>>>SQL<<<< SELECT orderInfo"); var orderInfo = OrderHelper.GetOrderInfo(Guid.Parse(uniqueOrderId)); var currentCulture = Thread.CurrentThread.CurrentCulture; var currentUICulture = Thread.CurrentThread.CurrentUICulture; Thread.CurrentThread.CurrentCulture = orderInfo.StoreInfo.CurrencyCultureInfo; Thread.CurrentThread.CurrentUICulture = orderInfo.StoreInfo.CurrencyCultureInfo; var serializedOrderInfo = DomainHelper.SerializeObjectToXmlString(orderInfo); var orderXml = new XmlDocument(); orderXml.LoadXml(serializedOrderInfo); var xmlDoc = orderXml.CreateNavigator(); Thread.CurrentThread.CurrentCulture = currentCulture; Thread.CurrentThread.CurrentUICulture = currentUICulture; return(xmlDoc); } return(new XmlDocument().CreateNavigator()); }
public ActionResult Create(MenteeViewModel viewModel) { if (!ModelState.IsValid) { var errors = ModelState.Where(v => v.Value.Errors.Any()); return(View(viewModel)); } // New person that represents the mentee Person mentee = new Person(viewModel.Mentee); // Make sure we set the user as Mentee mentee.PersonTypeId = DomainHelper.GetIdByKeyValue(ref this._db, "PersonType", "Mentee"); mentee.StatusId = DomainHelper.GetIdByKeyValue(ref _db, "StatusCode", "Active"); this._db.People.Add(mentee); // Home Address Address homeAddr = new Address(viewModel.HomeAddress); PersonAddress p2a = new PersonAddress(mentee.id, homeAddr.id, DomainHelper.GetIdByKeyValue(ref _db, "AddressType", "Home")); this._db.Addresses.Add(homeAddr); this._db.PersonToAddress.Add(p2a); // Save changes this._db.SaveChanges(); return(RedirectToAction("Index")); }
public static void ShowExceptionMessage(Exception ex) { if (ex is StaleObjectStateException staleObjectStateException) { var type = OrmConfig.FindMappingByFullClassName(staleObjectStateException.EntityName).MappedClass; var objectName = DomainHelper.GetSubjectNames(type); string message; switch (objectName.Gender) { case GrammaticalGender.Feminine: message = "Сохраняемая <b>{0}</b> c номером <b>{1}</b> была кем то изменена."; break; case GrammaticalGender.Neuter: message = "Сохраняемое <b>{0}</b> c номером <b>{1}</b> было кем то изменено."; break; case GrammaticalGender.Masculine: default: message = "Сохраняемый <b>{0}</b> c номером <b>{1}</b> был кем то изменен."; break; } message = String.Format(message + "\nВаши изменения не будут записаны, чтобы не потерять чужие изменения. \nПереоткройте вкладку.", objectName?.Nominative ?? type.Name, staleObjectStateException.Identifier); MessageDialogHelper.RunErrorDialog(message); } }
public async Task HandleAsync_XmlContainsSchemaError_StoresAvailableDataReturnData() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var organisation = helper.CreateOrganisation(); var scheme = helper.CreateScheme(organisation); database.Model.SaveChanges(); var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext); var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>( "Test XML string", A.Dummy<SchemeReturn>(), new List<XmlValidationError> { new XmlValidationError(ErrorLevel.Error, XmlErrorType.Schema, "Error text") }); A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._)) .Returns(xmlGeneratorResult); // Act var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id, fileName: "XML file name"); // Assert var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId); Assert.Equal(scheme.Id, dataReturnUpload.Scheme.Id); Assert.Equal("Test XML string", dataReturnUpload.RawData.Data); Assert.Equal("XML file name", dataReturnUpload.FileName); Assert.NotEqual(TimeSpan.Zero, dataReturnUpload.ProcessTime); } }
public override bool TryFindContent(PublishedRequest contentRequest) { string route; if (contentRequest.HasDomain) { route = contentRequest.Domain.ContentId.ToString() + DomainHelper.PathRelativeToDomain(contentRequest.Domain.Uri, contentRequest.Uri.GetAbsolutePathDecoded()); } else { route = contentRequest.Uri.GetAbsolutePathDecoded(); } // This simple logic should do the trick: basically if I find an url with more than 4 segments (the 3 date parts and the slug) // I leave the last segment (the slug), remove the 3 date parts, and keep all the rest. var segmentLength = contentRequest.Uri.Segments.Length; if (segmentLength > 4) { var stringDate = contentRequest.Uri.Segments[segmentLength - 4] + contentRequest.Uri.Segments[segmentLength - 3] + contentRequest.Uri.Segments[segmentLength - 2].TrimEnd("/"); DateTime postDate; try { postDate = DateTime.ParseExact(stringDate, "yyyy/MM/dd", CultureInfo.InvariantCulture); } catch (FormatException) { return(false); } var newRoute = string.Empty; for (int i = 0; i < segmentLength; i++) { if (i < segmentLength - 4 || i > segmentLength - 2) { newRoute += contentRequest.Uri.Segments[i]; } } var node = FindContent(contentRequest, newRoute); contentRequest.PublishedContent = null; // If by chance something matches the format pattern I check again if there is sucn a node and if it's an articulate post if (node == null || (node.ContentType.Alias != "ArticulateRichText" && node.ContentType.Alias != "ArticulateMarkdown")) { return(false); } if (!node.Parent.Parent.Value <bool>("useDateFormatForUrl")) { return(false); } if (node.Value <DateTime>("publishedDate").Date != postDate.Date) { return(false); } contentRequest.PublishedContent = node; return(true); } return(false); }
public async Task FetchAatfByReturnId_GivenReturnId_ReturnedListShouldOnlyContainReturnRelatedAatfs() { using (var database = new DatabaseWrapper()) { var helper = new ModelHelper(database.Model); var domainHelper = new DomainHelper(database.WeeeContext); var dataAccess = new FetchAatfDataAccess(database.WeeeContext, quarterWindowFactory); var genericDataAccess = new GenericDataAccess(database.WeeeContext); var aatf = await CreateAatf(database, FacilityType.Aatf, DateTime.Now, 2019); var @return = new EA.Weee.Domain.AatfReturn.Return(aatf.Organisation, new Quarter(2019, QuarterType.Q1), database.WeeeContext.Users.First().Id, FacilityType.Aatf); await genericDataAccess.Add(new ReturnAatf(aatf, @return)); var @return2 = new EA.Weee.Domain.AatfReturn.Return(aatf.Organisation, new Quarter(2019, QuarterType.Q1), database.WeeeContext.Users.First().Id, FacilityType.Aatf); var aatf2 = await CreateAatf(database, FacilityType.Aatf, DateTime.Now, 2019); await genericDataAccess.Add(new ReturnAatf(aatf2, @return2)); var aatfList = await dataAccess.FetchAatfByReturnId(@return.Id); aatfList.Count.Should().Be(1); aatfList.Should().Contain(aatf); aatfList.Should().NotContain(aatf2); } }
// initialize a PublishedContentCache instance with // an XmlStore containing the master xml // an IAppCache that should be at request-level // a RoutesCache - need to cleanup that one // a preview token string (or null if not previewing) public PublishedContentCache( XmlStore xmlStore, // an XmlStore containing the master xml IDomainCache domainCache, // an IDomainCache implementation IAppCache appCache, // an IAppCache that should be at request-level IGlobalSettings globalSettings, ISiteDomainHelper siteDomainHelper, IUmbracoContextAccessor umbracoContextAccessor, PublishedContentTypeCache contentTypeCache, // a PublishedContentType cache RoutesCache routesCache, // a RoutesCache string previewToken) // a preview token string (or null if not previewing) : base(previewToken.IsNullOrWhiteSpace() == false) { _appCache = appCache; _globalSettings = globalSettings; _umbracoContextAccessor = umbracoContextAccessor; _routesCache = routesCache; // may be null for unit-testing _contentTypeCache = contentTypeCache; _domainCache = domainCache; _domainHelper = new DomainHelper(_domainCache, siteDomainHelper); _xmlStore = xmlStore; _xml = _xmlStore.Xml; // capture - because the cache has to remain consistent if (previewToken.IsNullOrWhiteSpace() == false) { _previewContent = new PreviewContent(_xmlStore, previewToken); } }
/// <summary> /// 获取店铺头信息 /// </summary> /// <param name="supplierID"></param> /// <returns></returns> public StoreInfoModel GetStoreInfoById(int supplierId, int language) { StoreInfoModel storeInfoModel = new StoreInfoModel(); var model = supplierDal.GetStoreInfoById(supplierId); if (model != null) { storeInfoModel.SupplierID = model.SupplierID; storeInfoModel.StorePageDesc = model.StorePageDesc; storeInfoModel.Address = model.Address; storeInfoModel.Address_English = model.Address_English; storeInfoModel.Address_Sample = model.Address_Sample; if (!string.IsNullOrEmpty(model.StoreName)) { storeInfoModel.StoreName = model.StoreName; } else { if (language == 1) { storeInfoModel.StoreName = model.CompanyName_Sample; storeInfoModel.StorePageDesc = model.Description_Sample; } else { storeInfoModel.StorePageDesc = model.Description; storeInfoModel.StoreName = model.CompanyName; } } storeInfoModel.StoreLogoPath = DomainHelper.GetImageUrl(model.StoreLogoPath); storeInfoModel.StoreBannerPath = DomainHelper.GetImageUrl(model.StoreBannerPath); } return(storeInfoModel); }
public async Task FetchById_GivenAatfId_CorrectAatfShouldBeReturned() { using (var database = new DatabaseWrapper()) { var helper = new ModelHelper(database.Model); var domainHelper = new DomainHelper(database.WeeeContext); var dataAccess = new FetchAatfDataAccess(database.WeeeContext, quarterWindowFactory); var genericDataAccess = new GenericDataAccess(database.WeeeContext); var aatf = await CreateAatf(database, FacilityType.Aatf, DateTime.Now, 2019); var @return = new EA.Weee.Domain.AatfReturn.Return(aatf.Organisation, new Quarter(2019, QuarterType.Q1), database.WeeeContext.Users.First().Id, FacilityType.Aatf); await genericDataAccess.Add(new ReturnAatf(aatf, @return)); var aatf2 = await CreateAatf(database, FacilityType.Aatf, DateTime.Now, 2019); var @return2 = new EA.Weee.Domain.AatfReturn.Return(aatf2.Organisation, new Quarter(2019, QuarterType.Q1), database.WeeeContext.Users.First().Id, FacilityType.Aatf); await genericDataAccess.Add(new ReturnAatf(aatf2, @return2)); var returnedAatf = await dataAccess.FetchById(aatf.Id); returnedAatf.Should().BeEquivalentTo(aatf); } }
public ActionResult Register(NewUserViewModel viewModel) { // Log any logged-in user out this.ClearSession(); if (!ModelState.IsValid) { return(View(viewModel)); } // Create the new user profile UserProfile profile = new UserProfile(); profile.Username = viewModel.Username; profile.Salt = CryptHelper.CreateSalt(256); profile.Password = CryptHelper.CreatePasswordHash(viewModel.Password, profile.Salt); profile.RoleId = DomainHelper.GetIdByKeyValue(ref this._db, "PersonType", "Mentor"); profile.CanBeDeleted = true; // Add the profile to the dataset this._db.UserProfiles.Add(profile); // Save the changes this._db.SaveChanges(); // Let the user in FormsAuthentication.SetAuthCookie(profile.Username, true); // Send the user on to the registration page return(RedirectToAction("Index", "Registration")); }
public void Initialize(IInitializationControl control) { if (HttpContext.Current == null) { control.NotNow(); return; } _aliasses = new UwebshopAliassesXMLConfig(); const string path = "/App_Plugins/uWebshop/config/ContentMapping.config"; if (!System.IO.File.Exists(HttpContext.Current.Server.MapPath(path))) { control.Debug("No Aliasses.config"); } else { try { _aliasses = DomainHelper.DeserializeXmlStringToObject <UwebshopAliassesXMLConfig>(System.IO.File.ReadAllText(HttpContext.Current.Server.MapPath(path))); Log.Instance.LogDebug("ContentMapping xml loaded"); control.Debug("Done loading Aliasses.config"); } catch (Exception ex) { Log.Instance.LogError(ex, "ContentMapping xml loading failed"); control.FatalError("Failure deserializing " + path); throw; } } InitNodeAliasses.Initialize(_aliasses); }
public void Delete(string id) { DomainHelper.Publish(new DeleteDepartmentEvent() { Id = id }); }
/// <summary> /// Returns unique products witch have one ore more tags in common with the given productId /// </summary> public static XPathNavigator GetMatchtingTagProducts(int productId) { var currentProduct = DomainHelper.GetProductById(productId); var productList = new List <Product>(); var productService = IO.Container.Resolve <IProductService>(); foreach (var p in from currentTag in currentProduct.Tags select productService.GetAll(StoreHelper.CurrentLocalization).Where(x => x.Tags.Contains(currentTag) && x.Id != productId) into matchedProducts from p in matchedProducts where !productList.Contains(p) select p) { productList.Add(p); } var stream1 = new MemoryStream(); //Serialize the Record object to a memory stream using DataContractSerializer. var serializer = new DataContractSerializer(typeof(List <Product>)); serializer.WriteObject(stream1, productList); stream1.Position = 0; var result = new StreamReader(stream1).ReadToEnd(); var doc = new XmlDocument(); doc.LoadXml(result); return(doc.CreateNavigator()); }
public async Task FetchAatfByApprovalNumber_GivenApprovalNumber_ReturnedShouldBeAatf(Core.AatfReturn.FacilityType type) { FacilityType facilityType; if (type == Core.AatfReturn.FacilityType.Aatf) { facilityType = FacilityType.Aatf; } else { facilityType = FacilityType.Ae; } using (var database = new DatabaseWrapper()) { ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); FetchAatfDataAccess dataAccess = new FetchAatfDataAccess(database.WeeeContext, quarterWindowFactory); GenericDataAccess genericDataAccess = new GenericDataAccess(database.WeeeContext); string approvalNumber = "test"; Aatf aatf = await CreateAatf(database, facilityType, DateTime.Now, 2019, approvalNumber); await genericDataAccess.Add(aatf); Aatf result = await dataAccess.FetchByApprovalNumber(approvalNumber); Assert.NotNull(result); Assert.Equal(approvalNumber, result.ApprovalNumber); Assert.Equal(facilityType, result.FacilityType); } }
public static bool NHibernateStaleObjectStateExceptionHandler(Exception exception, IApplicationInfo application, UserBase user, IInteractiveMessage interactiveMessage) { var staleObjectStateException = ExceptionHelper.FindExceptionTypeInInner <NHibernate.StaleObjectStateException>(exception); if (staleObjectStateException != null) { var type = OrmConfig.FindMappingByFullClassName(staleObjectStateException.EntityName).MappedClass; var objectName = DomainHelper.GetSubjectNames(type); string message; switch (objectName?.Gender) { case GrammaticalGender.Feminine: message = "Сохраняемая <b>{0}</b> c номером <b>{1}</b> была кем то изменена."; break; case GrammaticalGender.Neuter: message = "Сохраняемое <b>{0}</b> c номером <b>{1}</b> было кем то изменено."; break; case GrammaticalGender.Masculine: default: message = "Сохраняемый <b>{0}</b> c номером <b>{1}</b> был кем то изменен."; break; } message = String.Format(message + "\nВаши изменения не будут записаны, чтобы не потерять чужие изменения. \nПереоткройте вкладку.", objectName?.Nominative ?? type.Name, staleObjectStateException.Identifier); interactiveMessage.ShowMessage(QS.Dialog.ImportanceLevel.Warning, message); return(true); } return(false); }
public double Build() { function.Precision = precision; var minimum = double.MaxValue; for (var currentIteration = 1; currentIteration <= iterations; currentIteration++) { var randomState = DomainHelper.RandomDimensionalBinaryValueInDomainRange( function.GetDomain(), function.GetDimensionDefinition(), precision); var neighboursExhausted = false; while (!neighboursExhausted) { var neighbourhood = GetNeighbourhood(randomState); var improvement = strategy.PickImprovement(neighbourhood, function, minimum); if (improvement == null) { neighboursExhausted = true; } else { minimum = function.GetValue(improvement, new BinarySetToDoubleSetConverter()); } } } return(minimum); }
public void Update(string name, string desc, bool isEnabled, string id) { DomainHelper.Publish(new UpdateDepartmentEvent() { Desc = desc, IsEnabled = isEnabled, Name = name, Id = id }); }
public async Task GetNumberOfDataReturnSubmissionsAsync_ReturnsDataForSpecifiedSchemeOnly() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme1 = helper.CreateScheme(); helper.CreateDataReturnVersion(scheme1, 2016, 1, true); helper.CreateDataReturnVersion(scheme1, 2016, 1, true); var scheme2 = helper.CreateScheme(); helper.CreateDataReturnVersion(scheme2, 2016, 1, true); database.Model.SaveChanges(); var dataAccess = new SchemeDataReturnSubmissionEventHandlerDataAccess(database.WeeeContext); // Act var result = await dataAccess.GetNumberOfDataReturnSubmissionsAsync(domainHelper.GetScheme(scheme2.Id), 2016, QuarterType.Q1); // Assert Assert.Equal(1, result); } }
public void Delete(string id) { DomainHelper.Publish(new DeleteUserEvent() { Id = id }); }
public void Clear() { if ((m_pluginList == null) || (m_pluginList.Count <= 0)) { return; } // while (m_pluginList.Count > 0) { PluginInfo <T> pi = m_pluginList[0]; if (pi == null) { continue; } // IDisposable ids = pi.Plugin as IDisposable; if (ids != null) { ids.Dispose(); } // DomainHelper.UnloadDomain(pi.Domain); m_pluginList.RemoveAt(0); } }
public void Update(string name, string desc, string departmentId, bool isEnabled, string id) { DomainHelper.Publish(new UpdateDutyEvent() { DepartmentId = departmentId, Desc = desc, Id = id, IsEnabled = true, Name = name }); }
public async Task GetPreviousSubmission_ReturnsNullIfPreviousUploadButNoSubmission() { using (var database = new DatabaseWrapper()) { // Arrange DataReturnSubmissionsDataAccess dataAccess = new DataReturnSubmissionsDataAccess(database.WeeeContext); ModelHelper modelHelper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme = modelHelper.CreateScheme(); var dataReturnVersion = modelHelper.CreateDataReturnVersion(scheme, 2015, 1, false); var dataReturnVersion2 = modelHelper.CreateDataReturnVersion(scheme, 2015, 1, true); dataReturnVersion2.SubmittedDate = new DateTime(2015, 2, 1); database.Model.SaveChanges(); var domainDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion2.Id); // Act var result = await dataAccess.GetPreviousSubmission(domainDataReturnVersion); // Assert Assert.Null(result); } }
public static void InitGlobal(Dictionary <Guid, Domain> localcachelist) { string name = AppSettings.ThemeDomain; if (name != null && name.Contains(".")) { name = DomainHelper.GetRootDomain(name); } if (!string.IsNullOrEmpty(name)) { Guid hash = Lib.Security.Hash.ComputeGuidIgnoreCase(name); Domain domain = new Domain() { DomainName = name, ExpirationDate = DateTime.Now.AddYears(100) }; localcachelist[hash] = domain; } name = AppSettings.HostDomain; if (name != null && name.Contains(".")) { name = DomainHelper.GetRootDomain(name); } if (!string.IsNullOrEmpty(name)) { Guid hash = Lib.Security.Hash.ComputeGuidIgnoreCase(name); Domain domain = new Domain() { DomainName = name, ExpirationDate = DateTime.Now.AddYears(100) }; localcachelist[hash] = domain; } }
public async Task Submit_SetsDataReturnVersionAsSubmitted() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme = helper.CreateScheme(); var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 1, false); database.Model.SaveChanges(); var dbDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion.Id); var dataAccess = new SubmitReturnVersionDataAccess(database.WeeeContext); // Act await dataAccess.Submit(dbDataReturnVersion); // Assert Assert.Equal(dataReturnVersion.Id, dbDataReturnVersion.Id); Assert.True(dbDataReturnVersion.IsSubmitted); Assert.NotNull(dbDataReturnVersion.SubmittedDate); Assert.Equal(database.WeeeContext.GetCurrentUser(), dbDataReturnVersion.SubmittingUserId); Assert.Equal(dataReturnVersion.Id, dbDataReturnVersion.DataReturn.CurrentVersion.Id); } }
public void Update(string userName, string realName, string password, string idNum, string phoneNum, int gender, string address, string degree, DateTime entryTime, string nationId, DateTime birthday, int status, string id) { DomainHelper.Publish(new UpdateUserEvent() { Address = address, Birthday = birthday, Degree = degree, EntryTime = entryTime, Gender = gender, Id = id, IdNum = idNum, NationId = nationId, Password = password, PhoneNum = phoneNum, RealName = realName, Status = status, UserName = userName }); }
public async Task FetchDataReturnOrDefault_ReturnsDataReturnForSpecifiedQuarterOnly() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme = helper.CreateScheme(); helper.CreateDataReturnVersion(scheme, 2016, 1, true); var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 2, true); database.Model.SaveChanges(); var dataAccess = new DataReturnVersionBuilderDataAccess(domainHelper.GetScheme(scheme.Id), new Quarter(2016, QuarterType.Q2), database.WeeeContext); // Act var result = await dataAccess.FetchDataReturnOrDefault(); // Assert Assert.Equal(QuarterType.Q2, result.Quarter.Q); Assert.Equal(dataReturnVersion.DataReturn.Id, result.Id); } }
public override string GetUserNameByEmail(string email) { this.VerifyKeys(); if (!String.IsNullOrEmpty(email)) { DomainHelper.CheckForDomain(Settings.Default.AWSMembershipDomain, _simpleDBClient); SelectRequest request = new SelectRequest(); request.SelectExpression = String.Concat( "Select * from `", Settings.Default.AWSMembershipDomain, "` where Email='", email, "'" ); SelectResponse response = this._simpleDBClient.Select(request); if (response.Items.Count == 0) { return(String.Empty); } else { return(response.Items[0].Name); } } throw new ArgumentNullException("email", "The email passed in is null"); }
public async Task GetRegisteredProducer_ReturnsProducerForMatchingRegistrationNumberOnly() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme = helper.CreateScheme(); var memberUpload1 = helper.CreateMemberUpload(scheme); memberUpload1.ComplianceYear = 2016; memberUpload1.IsSubmitted = true; helper.CreateProducerAsCompany(memberUpload1, "AAAA"); var producer = helper.GetOrCreateRegisteredProducer(scheme, 2016, "BBBB"); var memberUpload2 = helper.CreateMemberUpload(scheme); memberUpload2.ComplianceYear = 2016; memberUpload2.IsSubmitted = true; helper.CreateProducerAsCompany(memberUpload2, "BBBB"); database.Model.SaveChanges(); var dataAccess = new DataReturnVersionBuilderDataAccess(domainHelper.GetScheme(scheme.Id), new Quarter(2016, QuarterType.Q1), database.WeeeContext); // Act var result = await dataAccess.GetRegisteredProducer("BBBB"); // Assert Assert.Equal("BBBB", result.ProducerRegistrationNumber); Assert.Equal(producer.Id, result.Id); } }
public async Task FetchDataReturnOrDefault_ReturnsDataReturnForSpecifiedYearOnly() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme = helper.CreateScheme(); helper.CreateDataReturnVersion(scheme, 2016, 1, true); var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2017, 1, true); database.Model.SaveChanges(); var dataAccess = new DataReturnVersionBuilderDataAccess(domainHelper.GetScheme(scheme.Id), new Quarter(2017, QuarterType.Q1), database.WeeeContext); // Act var result = await dataAccess.FetchDataReturnOrDefault(); // Assert Assert.Equal(2017, result.Quarter.Year); Assert.Equal(dataReturnVersion.DataReturn.Id, result.Id); } }
public async Task HandleAsync_CreatesUserWithStandardUserRole() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var user = helper.GetOrCreateUser("TestUser"); user.Email = "*****@*****.**"; database.Model.SaveChanges(); var handler = new AddCompetentAuthorityUserHandler(database.WeeeContext, A.Dummy <ITestUserEmailDomains>()); // Act var competentAuthorityUserId = await handler.HandleAsync(new AddCompetentAuthorityUser(user.Id)); var competentAuthorityUser = domainHelper.GetCompetentAuthorityUser(competentAuthorityUserId); // Assert Assert.Equal(user.Id, competentAuthorityUser.UserId); Assert.NotNull(competentAuthorityUser.Role); Assert.Equal("InternalUser", competentAuthorityUser.Role.Name); } }
public async Task UpdateUserRoleAndStatus_UpdatesUserRoleAndStatusInDatabase() { using (var databaseWrapper = new DatabaseWrapper()) { ModelHelper modelHelper = new ModelHelper(databaseWrapper.Model); DomainHelper domainHelper = new DomainHelper(databaseWrapper.WeeeContext); var userRole = databaseWrapper.Model.Roles.Single(r => r.Name == "InternalUser"); var user = modelHelper.GetOrCreateCompetentAuthorityUser("TestUser", 1, userRole); databaseWrapper.Model.SaveChanges(); var competentAuthorityUser = domainHelper.GetCompetentAuthorityUser(user.Id); var adminRole = domainHelper.GetRole("InternalAdmin"); var dataAccess = new UpdateCompetentAuthorityUserRoleAndStatusDataAccess(databaseWrapper.WeeeContext); await dataAccess.UpdateUserRoleAndStatus(competentAuthorityUser, adminRole, Core.Shared.UserStatus.Active); Assert.Equal(UserStatus.Active, competentAuthorityUser.UserStatus); Assert.Equal("InternalAdmin", competentAuthorityUser.Role.Name); } }
public async Task FetchDataReturnOrDefault_ResultIncludesUnsubmittedDataReturn() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme = helper.CreateScheme(); var dataReturn = helper.CreateDataReturn(scheme, 2016, 1); database.Model.SaveChanges(); var dataAccess = new DataReturnVersionBuilderDataAccess(domainHelper.GetScheme(scheme.Id), new Quarter(2016, QuarterType.Q1), database.WeeeContext); // Act var result = await dataAccess.FetchDataReturnOrDefault(); // Assert Assert.NotNull(result); Assert.Equal(dataReturn.Id, result.Id); Assert.Null(dataReturn.CurrentDataReturnVersion); } }
public async Task AddAndSaveAsync_AddsDataReturnUpload_ToWeeeContextDataReturnsUploads() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme = helper.CreateScheme(); helper.GetOrCreateRegisteredProducer(scheme, 2016, "AAAA"); database.Model.SaveChanges(); var upload = new Domain.DataReturns.DataReturnUpload(domainHelper.GetScheme(scheme.Id), "Upload Data", new List<Domain.DataReturns.DataReturnUploadError>(), "File name", 2016, 1); var dataAccess = new ProcessDataReturnXmlFileDataAccess(database.WeeeContext); // Act await dataAccess.AddAndSaveAsync(upload); // Assert Assert.Single(database.WeeeContext.DataReturnsUploads, u => u.Id == upload.Id); } }
public async Task HandleAsync_XmlContainsError_DoesNotReturnVersionForDataUpload() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var organisation = helper.CreateOrganisation(); var scheme = helper.CreateScheme(organisation); var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 3, false); database.Model.SaveChanges(); var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext); var schemeReturn = new SchemeReturn() { ComplianceYear = "2016", ReturnPeriod = SchemeReturnReturnPeriod.Quarter3JulySeptember }; var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>( "Test XML string", schemeReturn, new List<XmlValidationError>()); A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._)) .Returns(xmlGeneratorResult); var dbDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion.Id); var businessErrorAndWarning = new List<ErrorData> { new ErrorData("Error text", ErrorLevel.Error) }; var dataReturnVersionBuilderResult = new DataReturnVersionBuilderResult(dbDataReturnVersion, businessErrorAndWarning); A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A<SchemeReturn>._)) .Returns(dataReturnVersionBuilderResult); // Act var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id); // Assert var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId); Assert.Null(dataReturnUpload.DataReturnVersion); } }
public async Task HandleAsync_XmlDoesNotContainSchemaError_StoresAvailableDataReturnData() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var organisation = helper.CreateOrganisation(); var scheme = helper.CreateScheme(organisation); var dataReturnVersion = helper.CreateDataReturnVersion(scheme, 2016, 3, false); database.Model.SaveChanges(); var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext); var schemeReturn = new SchemeReturn() { ComplianceYear = "2016", ReturnPeriod = SchemeReturnReturnPeriod.Quarter3JulySeptember }; var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>( "Test XML string", schemeReturn, new List<XmlValidationError>()); A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._)) .Returns(xmlGeneratorResult); var dbDataReturnVersion = domainHelper.GetDataReturnVersion(dataReturnVersion.Id); var dataReturnVersionBuilderResult = new DataReturnVersionBuilderResult(dbDataReturnVersion, A.Dummy<List<ErrorData>>()); A.CallTo(() => builder.DataReturnVersionFromXmlBuilder.Build(A<SchemeReturn>._)) .Returns(dataReturnVersionBuilderResult); // Act var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id, fileName: "XML file name"); // Assert var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId); Assert.Equal(scheme.Id, dataReturnUpload.Scheme.Id); Assert.Equal("Test XML string", dataReturnUpload.RawData.Data); Assert.Equal("XML file name", dataReturnUpload.FileName); Assert.Equal(2016, dataReturnUpload.ComplianceYear); Assert.Equal(Convert.ToInt32(QuarterType.Q3), dataReturnUpload.Quarter); Assert.NotEqual(TimeSpan.Zero, dataReturnUpload.ProcessTime); } }
public async Task GetRegisteredProducer_ReturnsSubmittedProducerOnly() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var scheme = helper.CreateScheme(); helper.GetOrCreateRegisteredProducer(scheme, 2016, "BBBB"); database.Model.SaveChanges(); var dataAccess = new DataReturnVersionBuilderDataAccess(domainHelper.GetScheme(scheme.Id), new Quarter(2016, QuarterType.Q1), database.WeeeContext); // Act var result = await dataAccess.GetRegisteredProducer("BBBB"); // Assert Assert.Null(result); } }
public async Task HandleAsync_XmlContainsSchemaError_StoresSchemaErrors() { using (DatabaseWrapper database = new DatabaseWrapper()) { // Arrange ModelHelper helper = new ModelHelper(database.Model); DomainHelper domainHelper = new DomainHelper(database.WeeeContext); var organisation = helper.CreateOrganisation(); var scheme = helper.CreateScheme(organisation); database.Model.SaveChanges(); var builder = new ProcessDataReturnXmlFileHandlerBuilder(database.WeeeContext); var xmlGeneratorResult = new GenerateFromDataReturnXmlResult<SchemeReturn>( "Test XML string", A.Dummy<SchemeReturn>(), new List<XmlValidationError> { new XmlValidationError(ErrorLevel.Error, XmlErrorType.Schema, "Error text1"), new XmlValidationError(ErrorLevel.Error, XmlErrorType.Schema, "Error text2") }); A.CallTo(() => builder.XmlGenerator.GenerateDataReturns<SchemeReturn>(A<ProcessDataReturnXmlFile>._)) .Returns(xmlGeneratorResult); // Act var dataReturnUploadId = await builder.InvokeHandleAsync(organisation.Id); // Assert var dataReturnUpload = domainHelper.GetDataReturnUpload(dataReturnUploadId); Assert.Equal(2, dataReturnUpload.Errors.Count); Assert.All(dataReturnUpload.Errors, e => Assert.Equal(Domain.Error.UploadErrorType.Schema, e.ErrorType)); Assert.Contains(dataReturnUpload.Errors, p => p.ErrorLevel == Domain.Error.ErrorLevel.Error && p.Description == "Error text1"); Assert.Contains(dataReturnUpload.Errors, p => p.ErrorLevel == Domain.Error.ErrorLevel.Error && p.Description == "Error text2"); } }