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");
}
}
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);
}
}
