public void Invoke_ValidData_AddsDomainToDatabaseWithCorrectValues()
{
// prepare
var domainData = new DomainModel
{
Name = "testdomain"
};
DataAccess.Models.Domain domainSaved = null;
var mockedDomainrepository = new Mock <IDomainRepository>();
mockedDomainrepository.Setup(r => r.Add(It.IsAny <DataAccess.Models.Domain>()))
.Callback <DataAccess.Models.Domain>(u => domainSaved = u);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new AddNewDomain(mockedDomainrepository.Object, mockedUnitOfWork.Object);
// action
action.Invoke(domainData, Guid.NewGuid());
// assert
mockedDomainrepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.Domain>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Exactly(1));
Assert.Equal("testdomain", domainSaved.Name);
}
/// <summary>
/// Creates new event.
/// </summary>
/// <param name="eventType"></param>
/// <param name="location"></param>
/// <param name="registrationDate"></param>
/// <param name="completionDate"></param>
public HandlingEvent(HandlingEventType eventType, DomainModel.Potential.Location.Location location, DateTime registrationDate, DateTime completionDate)
{
_eventType = eventType;
_completionDate = completionDate;
_registrationDate = registrationDate;
_location = location;
}
public override void Execute()
{
TDomainClass obj = MasterDetailsViewModel.ItemViewModelSelected.DomainObject;
DomainModel.Delete(obj.Key);
MasterDetailsViewModel.AfterModelDelete(obj.Key);
}
public override void Initialise()
{
_weaponModelSCDVM = new SelectionControlDVM <WeaponModel, WeaponModelDataViewModel>(
() => DataObject().WeaponModelId,
val =>
{
DataObject().WeaponModelId = DomainClassBase <WeaponModel> .IdOrNullId(val);
OnPropertyChanged(nameof(WeaponModelSelected));
});
// Selection-control DVM for at kunne se/rette brugte Jewels
_socketedJewelSCDVM = new SelectionControlDVM <Jewel, JewelDataViewModel>(
() => SocketedJewelSelectedId,
val => SocketedJewelSelectedId = val,
j => j.WeaponId == DataObject().Id);
// Selection-control DVM for at kunne se/rette frie Jewels
_freeJewelSCDVM = new SelectionControlDVM <Jewel, JewelDataViewModel>(
() => FreeJewelSelectedId,
val => FreeJewelSelectedId = val,
j => j.WeaponId == null);
// Command-objekter til hhv. at droppe eller tilføje en Jewel
_dropJewelCommand = new ReferenceChangeCommand <Jewel>(j => j.WeaponId = null);
_addJewelCommand = new AddJewelToWeaponCommand(j => j.WeaponId = DataObject().Id, DataObject(), this);
SocketedJewelSelectedId = null;
FreeJewelSelectedId = null;
// Da drop/tilføj vil medføre ændringer i Jewel-Cataloget, som udføres
// fra Command-objekter, vil vi gerne notificeres om dette.
DomainModel.GetCatalog <Jewel>().CatalogChanged += JewelCatalogChanged;
}
public IEnumerable<DomainModel.News> GetNewsForPeriod(DomainModel.NewsPeriodEnum newsPeriod)
{
using (var newsRepo = ObjectFactory.GetInstance<INewsRepo>())
{
DateTime date = DateTime.Now;
switch(newsPeriod)
{
case NewsPeriodEnum.Month:
date.AddMonths(-1);
break;
case NewsPeriodEnum.Week:
date.AddDays(-7);
break;
case NewsPeriodEnum.Year:
date.AddYears(-1);
break;
case NewsPeriodEnum.All:
return Mapper.Map<IEnumerable<domain.News>>(newsRepo.GetAll());
default:
throw new InvalidOperationException("unknown newsPeriodEnum type");
}
var news = newsRepo.GetAll().Where(t => t.NewsDate >= date).ToList();
return Mapper.Map<IEnumerable<domain.News>>(news);
}
}
public IActionResult Get(int id, [FromQuery] DomainModel domainModel)
{
domainModel.DomainId = id;
var dm = _idomain.GetDomainFromId(domainModel);
return(Ok(dm));
}
// Constructors
public UpgradeHintsProcessor(
HandlerAccessor handlers,
MappingResolver resolver,
StoredDomainModel currentDomainModel,
StoredDomainModel extractedDomainModel,
StorageModel extractedStorageModel,
bool autoDetectTypesMovements)
{
ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, "currentDomainModel");
ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, "extractedDomainModel");
ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, "extractedStorageModel");
typeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>();
reverseTypeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>();
fieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
reverseFieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
this.resolver = resolver;
nameBuilder = handlers.NameBuilder;
domainModel = handlers.Domain.Model;
this.extractedStorageModel = extractedStorageModel;
currentModel = currentDomainModel;
currentTypes = currentModel.Types.ToDictionary(t => t.UnderlyingType);
extractedModel = extractedDomainModel;
extractedTypes = extractedModel.Types.ToDictionary(t => t.UnderlyingType);
this.autoDetectTypesMovements = autoDetectTypesMovements;
hints = new NativeTypeClassifier <UpgradeHint>(true);
suspiciousTypes = new List <StoredTypeInfo>();
}
/// <summary>
/// Get a Collection of all Rooms from one Hotel
/// </summary>
/// <param name="p_hotel">Hotelobject with an ID set</param>
/// <returns>Collection of Rooms.</returns>
public ICollection<Room> GetCollectionByHotel(DomainModel.Hotel p_hotel)
{
using (var context = new FhdwHotelContext())
{
return context.Room.Where(r => r.Hotel.ID == p_hotel.ID).ToList();
}
}
private async Task CreateRequest(string domainName)
{
HttpResponseMessage response;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(PackageConstants.BackEndDevsUrl);
client.DefaultRequestHeaders.TryAddWithoutValidation(PackageConstants.ContentTypeHeader, PackageConstants.ContentType);
var domainModel = new DomainModel {
DomainName = domainName
};
try
{
response = await client.PostAsJsonAsync(PackageConstants.BackEndDevsPostStatistic, domainModel);
}
catch (Exception ex)
{
throw new NotSuccessfullRequestException(ex.Message);
}
if (!response.IsSuccessStatusCode)
{
var message = (int)response.StatusCode + response.ReasonPhrase;
throw new NotSuccessfullRequestException(message);
}
}
}
public override void Execute()
{
TDomainClass obj = (TDomainClass)MasterDetailsViewModel.DetailsViewModel.DomainObject.Clone();
DomainModel.Insert(obj);
MasterDetailsViewModel.AfterModelInsert(obj);
}
private void CreateHostDesignerModel(ServiceContract sc)
{
hdStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(HostDesignerDomainModel));
hdDomainModel = hdStore.GetDomainModel <HostDesignerDomainModel>();
hdTransaction = hdStore.TransactionManager.BeginTransaction();
hdModel = (HostDesignerModel)hdDomainModel.CreateElement(new Partition(hdStore), typeof(HostDesignerModel), null);
HostApplication app = (HostApplication)hdStore.ElementFactory.CreateElement(HostApplication.DomainClassId);
app.ImplementationTechnology = new HostDesignerWcfExtensionProvider();
reference = (ServiceReference)hdStore.ElementFactory.CreateElement(ServiceReference.DomainClassId);
//mel://[DSLNAMESPACE]\[MODELELEMENTTYPE]\[MODELELEMENT.GUID]@[PROJECT]\[MODELFILE]
string serviceMoniker = string.Format(@"mel://{0}\{1}\{2}@{3}\{4}",
sc.GetType().Namespace,
serviceContractName,
sc.Id.ToString(),
serviceContractModelProjectName, serviceContractModelFileName);
reference.Name = serviceMelReferenceName;
reference.ServiceImplementationType = new MockModelBusReference(sc);
app.ServiceDescriptions.Add(reference);
}
public virtual void CaseArtefact(DomainModel.Ast.Artefact x)
{
x.Name.Visit(this);
x.Bases.ForEach(y => y.Visit(this));
x.Body.ForEach(a => a.Visit(this));
x.PropertyDefinitions.ForEach(y => y.Visit(this));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Clears this instance to its blank/initial state.
/// </summary>
/// <exception cref="ReadOnlyException">
/// Thrown when a Read Only error condition occurs.
/// </exception>
///-------------------------------------------------------------------------------------------------
protected virtual void ClearInternal()
{
if (IsReadOnly)
{
throw new ReadOnlyException();
}
var list = new List <IDomainCommand>();
foreach (var relationship in DomainModel.GetRelationships(SchemaRelationship, Source, End))
{
list.Add(new RemoveRelationshipCommand(relationship));
}
var session = EnsuresSession();
try
{
Session.Current.Execute(list.ToArray());
}
finally
{
if (session != null)
{
session.AcceptChanges();
session.Dispose();
}
}
}
public override object Execute(@DatabaseName@OperationContext context)
{
var results = context.Provider.GetAll <DomainModel.@ModelName@>();
return(new Get@ModelName@sResponse {
@ModelName@s = @[email protected](results)
});
public async Task Handle(PingPublisher notification, CancellationToken cancellationToken)
{
_logger.LogInformation($"Publish notification=> {notification.Model}");
//add correlation id
notification.Controller.HttpContext.Request.Headers.Add(Identifiers.CorrelationId, new StringValues(notification.CorrelationId.ToString()));
var request = new DomainModel <DomainModels.Business.PingDomain.Ping>
{
Header = new MessageHeader
{
CorrelationId = notification.CorrelationId
},
Body = notification.Model,
Footer = new MessageFooter
{
Sender = DomainModels.System.Identifiers.PingServiceName,
FingerPrint = notification.Controller.ActionDescriptor.Id,
Environment = notification.OperationalUnit.Environment,
Assembly = notification.OperationalUnit.Assembly,
Route = JsonConvert.SerializeObject(new Dictionary <string, string> {
{ Identifiers.MessagePublisherRoute, notification.MiddlewareConfiguration.MessagePublisherRoute }
}, Defaults.JsonSerializerSettings),
Hint = Enum.GetName(typeof(ResponseHint), ResponseHint.OK)
}
};
await new Function(_logger, DomainModels.System.Identifiers.RetryCount).Decorate(() =>
{
return(notification.MessagePublisher.Command(request));
});
}
/// <summary>
/// c-tor creating the object out of a given domain model.
/// </summary>
/// <param name="dm"></param>
public GameSituationStructure(DomainModel dm)
{
//adding gs to the structure
foreach (Situation si in dm.elements.situations.situationList)
{
gameSituations.Add(new GameSituation(si.id));
}
//adding competences to the gs in the structure
foreach (SituationRelation sir in dm.relations.situations.situations)
{
foreach (CompetenceSituation cs in sir.competences)
{
getGameSituationById(sir.id).Competences.Add(cs.id);
}
}
//adding successors of the gs - at the moment all gs are successors of all gs
foreach (GameSituation gs1 in gameSituations)
{
foreach (GameSituation gs2 in gameSituations)
{
gs1.Successors.Add(gs2);
}
}
//set initial gs
initialGameSituation = gameSituations[0];
}
public static DomainModel GenerateMatrix(RestfulGraphDatabase rgd)
{
string key = "key_get";
string value = "value";
DomainModel dm = new DomainModel();
DomainEntity thomas = new DomainEntity();
thomas.Properties["name"] = "Thomas Anderson";
thomas.Location = ( URI )rgd.CreateNode("{\"name\":\"" + "Thomas Anderson" + "\"}").Metadata.getFirst("Location");
dm.Add(thomas);
DomainEntity agent = new DomainEntity();
agent.Properties["name"] = "Agent Smith";
agent.Location = ( URI )rgd.CreateNode("{\"name\":\"" + "Agent Smith" + "\"}").Metadata.getFirst("Location");
dm.Add(agent);
dm.NodeIndexName = "matrixal-nodes";
dm.IndexedNodeKeyValues[key] = value;
dm.IndexedNodeUriToEntityMap[( URI )rgd.AddToNodeIndex(dm.NodeIndexName, null, null, "{\"key\": \"" + key + "\", \"value\":\"" + value + "\", \"uri\": \"" + thomas.Location + "\"}").Metadata.getFirst("Location")] = thomas;
dm.IndexedNodeUriToEntityMap[( URI )rgd.AddToNodeIndex(dm.NodeIndexName, null, null, "{\"key\": \"" + key + "\", \"value\":\"" + value + "\", \"uri\": \"" + agent.Location + "\"}").Metadata.getFirst("Location")] = agent;
return(dm);
}
public Merge MapToMerge(DomainModel Domain)
{
var Merge = new Merge();
MapMerge(Domain, Merge);
return(Merge);
}
public Add MapToAdd(DomainModel Domain)
{
var Add = new Add();
MapAddUpdate(Domain, Add as AddUpdateBase);
return(Add);
}
public EntityValidator(DomainModel domainModel)
{
FullName aggregateName = new FullName();
// Ensure entity doesn't have a schema of auth.
RuleFor(entity => entity.Schema)
.Must(schema => !schema.IsAuthSchema())
.WithMessage(entity => $"Entity '{entity.FullName}' uses the reserved schema '{SystemConventions.AuthSchema}'.");
// Ensure entity is assigned to a valid aggregate
RuleFor(entity => entity.FullName)
.Must(entityName => domainModel.AggregateFullNameByEntityFullName.TryGetValue(entityName, out aggregateName))
.WithMessage("Entity '{PropertyValue}' not assigned to any aggregate.");
// Ensure that each Entity's FullName.Schema are located in the Schemas in the DomainModel
RuleFor(entity => entity)
.Must(entity => domainModel.Schemas.Any(sc => sc.PhysicalName.Equals(entity.FullName.Schema)))
.WithMessage(entity => $"Entity '{entity.FullName}' uses an undefined schema.");
// If entity is not assigned to an aggregate, return
if (string.Equals(aggregateName.ToString(), "."))
{
return;
}
// Ensure aggregate returned above is a valid aggregate within the domain model
RuleFor(a => aggregateName)
.Must(entityName => domainModel.AggregateByName.ContainsKey(aggregateName))
.WithMessage("Aggregate '{PropertyValue}' not found in domain model.");
}
/// <summary>
/// Resolves address and reads the <see cref="DomainModel"/> record as an asynchronous operation.
/// </summary>
/// <param name="modelUri">The model URI.</param>
/// <param name="rootZoneUrl">The root zone URL where the resolving process shall start.</param>
/// <param name="log"><see cref="Action{T1, T2, T3}"/> encapsulating tracing functionality .</param>
/// <returns>Task{DomainModel}.</returns>
/// <exception cref="InvalidOperationException">Too many iteration in the resolving process.</exception>
public async Task <DomainModel> ResolveDomainModelAsync(Uri modelUri, Uri rootZoneUrl, Action <string, TraceEventType, Priority> log)
{
log($"Starting resolving address of the domain model descriptor for the model Uri {modelUri}", TraceEventType.Verbose, Priority.Low);
DomainDescriptor _lastDomainDescriptor = new DomainDescriptor()
{
NextStepRecordType = RecordType.DomainDescriptor
};
Uri _nextUri = rootZoneUrl;
int _iteration = 0;
do
{
_iteration++;
log($"Resolving address iteration {_iteration} address: {_nextUri}", TraceEventType.Verbose, Priority.Low);
if (_iteration > 16)
{
throw new InvalidOperationException("Too many iteration in the resolving process.");
}
_lastDomainDescriptor = await GetHTTPResponseAsync <DomainDescriptor>(_nextUri, log);
_nextUri = _lastDomainDescriptor.ResolveUri(modelUri);
} while (_lastDomainDescriptor.NextStepRecordType == RecordType.DomainDescriptor);
log($"Reading DomainModel at: {_nextUri}", TraceEventType.Verbose, Priority.Low);
Task <DomainModel> _DomainModelTask = GetHTTPResponseAsync <DomainModel>(_nextUri, log);
DomainModel _model = await _DomainModelTask;
_model.UniversalDiscoveryServiceLocator = _nextUri.ToString();
log($"Successfuly received and decoded the requested DomainModel record: {_nextUri}", TraceEventType.Verbose, Priority.Low);
return(_model);
}
public ModuleRequirements()
{
Domain = new DomainModel();
UIDefinitions = new UIDefinition[0];
RequredModules = new int[0];
Templates = new HtmlTemplate[0];
}
public virtual void CaseArchitecture(DomainModel.Ast.Architecture x)
{
x.Prolog.Visit(this);
x.Imports.ForEach(s => SymbolTable.Imports.Add(s));
x.Artefacts.ForEach(ar => ar.Visit(this));
x.Definitions.ForEach(d => d.Visit(this));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Adds a property.
/// </summary>
/// <exception cref="Exception">
/// Thrown when an exception error condition occurs.
/// </exception>
/// <param name="property">
/// The property definition.
/// </param>
/// <returns>
/// An ISchemaProperty.
/// </returns>
/// <exception cref="System.Exception">
/// Duplicate property name.
/// </exception>
///-------------------------------------------------------------------------------------------------
protected ISchemaProperty DefineProperty(ISchemaProperty property)
{
Contract.Requires(property, "property");
lock (_propertiesByName)
{
if (GetProperty(property.Name) != null)
{
throw new Hyperstore.Modeling.MemoryStore.DuplicateElementException(ExceptionMessages.DuplicatePropertyName);
}
_properties.Add(property);
_propertiesByName.TryAdd(property.Name, property);
}
var trace = DomainModel.Resolve <IHyperstoreTrace>(false);
if (trace != null)
{
trace.WriteTrace(TraceCategory.Metadata, ExceptionMessages.CreatePropertyWithIdForMetaclassFormat, property.Name, property.Id, ((IModelElement)this).Id);
}
var constraint = property.PropertySchema as Hyperstore.Modeling.Metadata.Constraints.IConstraint;
if (constraint != null && this.Schema.Constraints is IConstraintManagerInternal)
{
(this.Schema.Constraints as IConstraintManagerInternal).AddConstraint(property, constraint);
}
return(property);
}
public ActionResult Carrello()
{
DomainModel dm = new DomainModel();
ViewBag.prodotti = Session["products"] as List <Prodotto>;
return(View());
}
public ResponseModel Search(string item)
{
DomainModel db = new DomainModel();
List<Basic_Information> students = (from u in db.Basic_Information
where u.Name.Contains(item)
select u).ToList();
// List<Basic_Information> students = db.Basic_Information.Include(x => x.Class).Include(x => x.Department).Where(x => x.Phone == item).ToList();
if (true)
{
ResponseModel response = new ResponseModel()
{
Issucces = true,
Message = "Data",
Data = new List<Basic_Information>(students)
};
}
ResponseModel response1 = new ResponseModel()
{
Issucces = true,
Message = "Data Not found",
Data = new List<Basic_Information>(students)
};
return response1;
}
public static Person AssemblePerson(DomainModel.Person person)
{
Person dto = new Person();
dto.Id = (int)person.Id[0];
dto.Name = person.Name;
dto.Password = person.Password;
dto.Timestamp = person.Timestamp.Value;
ICollection addresses = person.Addresses;
if(addresses != null && addresses.Count > 0)
{
int addrCount = addresses.Count;
dto.Addresses = new Address[addrCount];
IEnumerator addrEnum = addresses.GetEnumerator();
for(int i = 0; i < addrCount; i++)
{
addrEnum.MoveNext();
dto.Addresses[i] = AssembleAddress((DomainModel.Address)addrEnum.Current);
}
}
// ICollection roles = person.Roles;
// if(roles != null && roles.Count > 0)
// {
// dto.Roles = new Role[roles.Count];
// IEnumerator roleEnum = roles.GetEnumerator();
// for(int i = 0; i < roles.Count; i++)
// {
// roleEnum.MoveNext();
// dto.Roles[i] = AssembleRole((DomainModel.Person.PersonRole)roleEnum.Current);
// }
// }
return dto;
}
private void MapAddUpdate(DomainModel Domain, AddUpdateBase AddUpdate)
{
MapBase(Domain, AddUpdate as IcimsModelBase);
//Doctor
if (Domain.Doctor != null)
{
AddUpdate.gp_surname = Domain.Doctor.Family;
AddUpdate.gp_fname = Domain.Doctor.Given;
if (Domain.Doctor.Contact != null)
{
if (Domain.Doctor.Contact.EmailList.Count > 0)
{
AddUpdate.gp_email = Domain.Doctor.Contact.EmailList[0];
}
if (Domain.Doctor.Contact.FaxList.Count > 0)
{
AddUpdate.gp_fax = Domain.Doctor.Contact.FaxList[0];
}
}
if (Domain.Doctor.Address != null)
{
AddUpdate.gp_addr_line_1 = Domain.Doctor.Address.AddressLineOne;
AddUpdate.gp_addr_line_2 = Domain.Doctor.Address.AddressLineTwo;
AddUpdate.gp_suburb = Domain.Doctor.Address.Suburb;
AddUpdate.gp_postcode = Domain.Doctor.Address.PostCode;
AddUpdate.gp_state = Domain.Doctor.Address.State;
}
}
}
private static void VisitDependencies(Guid modelId, Dictionary <Guid, int> headNodes, Dictionary <Guid, List <Guid> > directDependencies, DomainModel[] allModels, DomainModel[] results, ref int nextResultIndex)
{
int modelIndex = headNodes[modelId];
if (modelIndex < 0)
{
modelIndex = ~modelIndex;
}
DomainModel model = allModels[modelIndex];
if (model == null)
{
// Already processed
return;
}
allModels[modelIndex] = null;
List <Guid> dependencies;
if (directDependencies.TryGetValue(modelId, out dependencies))
{
for (int i = 0, count = dependencies.Count; i < count; ++i)
{
VisitDependencies(dependencies[i], headNodes, directDependencies, allModels, results, ref nextResultIndex);
}
}
results[nextResultIndex] = model;
++nextResultIndex;
}
public Update MapToUpdate(DomainModel Domain)
{
var Update = new Update();
MapAddUpdate(Domain, Update as AddUpdateBase);
return(Update);
}
public void SimpleTryBlockWithinOneMethodWithTwoCatchHandlers()
{
//Arrange
ITest test = new CorrectOrderCheck();
MethodDesc mainMethod = new MethodDesc("Main", 3)
.EntryPoint()
.AddInheritanceAttributeFlag(MethodInheritanceAttributes.Global)
.AddInstructions(new ILInstruction[]
{
new ILInstruction(ByteCode.Nop, "1. Just before try start").Data(1),
//----------try begin-------------
new ILInstruction(ByteCode.Nop, "2. At the try first instruction start").AddLabel("TryBeg").Data(2),
new ILInstruction(ByteCode.Nop, "3. Just before throw").Data(3),
new ILInstruction(ByteCode.Newobj, TempTypeLocator.InvalidOperationExceptionDesc.Methods[0].Metadata /*ctor*/),
new ILInstruction(ByteCode.Throw),
new ILInstruction(ByteCode.Nop, "Just after throw"),
new ILInstruction(ByteCode.Nop, "Just before try leave instruction"),
new ILInstruction(ByteCode.Leave, new Label("TryLeaveDest")).AddLabel("TryEnd"),
//----------try end-------------
new ILInstruction(ByteCode.Nop, "Between try and catch"),
//----------catch1 begin-------------
new ILInstruction(ByteCode.Nop, "4. At the catch1 start").AddLabel("Catch1Beg").Data(4),
new ILInstruction(ByteCode.Pop),
new ILInstruction(ByteCode.Nop, "5. Just before catch1 leave instruction").Data(5),
new ILInstruction(ByteCode.Leave, new Label("CatchLeaveDest")).AddLabel("Catch1End"),
//----------catch1 end-------------
//----------catch2 begin-------------
new ILInstruction(ByteCode.Pop).AddLabel("Catch2Beg"),
new ILInstruction(ByteCode.Nop, "At the catch2 start"),
new ILInstruction(ByteCode.Nop, "Just before catch2 leave instruction"),
new ILInstruction(ByteCode.Leave, new Label("CatchLeaveDest")).AddLabel("Catch2End"),
//----------catch2 end-------------
new ILInstruction(ByteCode.Nop, "Instruction where try leave points").AddLabel("TryLeaveDest"),
new ILInstruction(ByteCode.Nop, "6(end). Instruction where catch leave points").AddLabel("CatchLeaveDest").Data(6),
new ILInstruction(ByteCode.Ret)
});
mainMethod.EHTable.AddCatchHandler("TryBeg", "TryEnd", new ClassToken("System.InvalidOperationException", false), "Catch1Beg", "Catch1End");
mainMethod.EHTable.AddCatchHandler("TryBeg", "TryEnd", new ClassToken("System.Exception", false), "Catch2Beg", "Catch2End");
CompiledModel compiledModel = new CompiledModel()
.AddMethod(mainMethod);
DomainModel domainModel = new DomainModel(new GCHeap.Factory(), new TypesHeap.Factory());
domainModel.LoadType(TempTypeLocator.ObjectDesc);
domainModel.LoadType(TempTypeLocator.ExceptionDesc);
domainModel.LoadType(TempTypeLocator.InvalidOperationExceptionDesc);
var executor = domainModel.GetExecutor(compiledModel, new ILOperationSet());
//Act
executor.Start();
//Assert
Assert.IsTrue(test.Success());
}
// Constructors
public DomainModelConverter(
HandlerAccessor handlers,
ITypeIdProvider typeIdProvider,
PartialIndexFilterCompiler compiler,
MappingResolver resolver,
IFullTextCatalogNameBuilder fulltextCatalogNameBuilder,
bool isUpgradingStage)
{
ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
ArgumentValidator.EnsureArgumentNotNull(typeIdProvider, "typeIdProvider");
ArgumentValidator.EnsureArgumentNotNull(compiler, "compiler");
ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
this.handlers = handlers;
this.compiler = compiler;
this.typeIdProvider = typeIdProvider;
this.resolver = resolver;
this.isUpgradingStage = isUpgradingStage;
this.fulltextCatalogNameBuilder = fulltextCatalogNameBuilder;
sourceModel = handlers.Domain.Model;
configuration = handlers.Domain.Configuration;
providerInfo = handlers.ProviderInfo;
driver = handlers.StorageDriver;
nameBuilder = handlers.NameBuilder;
FieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>();
StorageModel = null;
CurrentModelTypes = new Dictionary <string, StoredTypeInfo>();
}
public ActionResult VisualizzaCommessa(string commessa)
{
DomainModel model = new DomainModel();
if (commessa.Length == 0)
{
ViewBag.Message = "Inserire un nome di commessa";
}
else
{
try{
DTCommessa dTCommessa = model.CercaCommessa(commessa);
if (dTCommessa != null)
{
List <DTGiorno> giorni = model.GiorniCommessa(dTCommessa.Id, P.Matricola);
if (giorni != null && giorni.Count > 0)
{
ViewBag.NomeCommessa = dTCommessa.Nome;
ViewBag.Giorni = giorni;
}
else
{
ViewBag.Message = "Non hai mai lavorato su questa commessa!";
}
}
}catch (Exception e) {
ViewBag.Message = "Errore del server";
}
}
return(View("VisualizzaCommessa"));
}
public async Task <IActionResult> PutDomainModel([FromRoute] int id, [FromBody] DomainModel domainModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != domainModel.DomainId)
{
return(BadRequest());
}
context.Entry(domainModel).State = EntityState.Modified;
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DomainModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IHttpActionResult> DeleteDomainModel([FromUri] string id)
{
try
{
DomainModel DomainModel = await VhostService.FindByIdAsync(ThreadStaticObject.UserId, id);
if (DomainModel == null)
{
return(NotFound());
}
ServiceResultMessage result = await VhostService.RemoveAsync(ThreadStaticObject.UserId, id);
return(Json(new DjLiveResponse <dynamic>(DomainModel)));
}
catch (Exception e)
{
var errorId = Guid.NewGuid().Str();
LogHelper.Error(errorId, e);
return(Json(new DjLiveResponse <dynamic>()
{
ApiCode = ApiCode.UnExceptError, Message = $@"发生未知错误,请联系管理员,错误代码:{errorId}"
}));
}
}
public ActionResult Single(int id)
{
DomainModel dm = new DomainModel();
ViewBag.Products = dm.CercaId(id);
return(View());
}
protected override void Act()
{
var domainModelDefinitions = new DomainModelDefinitions(
new SchemaDefinition("schema", "schema"),
new[]
{
new AggregateDefinition(
new FullName("schema", "Aggregate"),
new[]
{
new FullName("schema", "AChild")
})
},
new[]
{
new EntityDefinition("schema", "Aggregate", new EntityPropertyDefinition[0], new EntityIdentifierDefinition[0]),
new EntityDefinition("schema", "AChild", new EntityPropertyDefinition[0], new EntityIdentifierDefinition[0])
},
new AssociationDefinition[0],
new AggregateExtensionDefinition[0]);
var builder = new DomainModelBuilder(
new[]
{
domainModelDefinitions
});
_domainModel = builder.Build();
}
public bool Get(string userName)
{
DomainModel db = new DomainModel();
List<Department> deptsList = (from u in db.Departments
where u.Department_Name.Contains(userName)
select u).ToList();
return deptsList.Count == 0;
}
public static OrderDetail AssembleOrderDetail(DomainModel.OrderDetail detail)
{
OrderDetail dto = new OrderDetail();
dto.ProductId = (int)detail.Product.Id[0];
dto.Quantity = detail.Quantity;
dto.UnitPrice = detail.UnitPrice;
dto.Timestamp = detail.Timestamp.Value;
return dto;
}
public UserJoinedChatEvent(
User user,
Chat chat,
DomainModel sender)
: base(user,
sender)
{
Chat = chat;
}
public HandlingActivity(HandlingEventType eventType, DomainModel.Potential.Location.Location location)
{
if (location == null)
{
throw new ArgumentNullException("location");
}
_eventType = eventType;
_location = location;
}
public RequestPasswordUpdate(
User user,
DomainModel sender,
bool sendEmail)
: base(user,
sender)
{
SendEmail = sendEmail;
}
public virtual void CaseApplication(DomainModel.Ast.Application x)
{
x.Name.Visit(this);
x.Bases.ForEach(y => y.Visit(this));
x.Applications.ForEach(y => y.Visit(this));
x.Dependencies.ForEach(y => y.Visit(this));
x.PropertyDefinitions.ForEach(y => y.Visit(this));
x.PropertyDeclarations.ForEach(y => y.Visit(this));
}
public OnlineUserUpdatedEvent(
User user,
OnlineUser onlineUser,
string connectionId,
DomainModel sender)
: base(user,
sender)
{
OnlineUser = onlineUser;
ConnectionId = connectionId;
}
public MediaResourceCreateFailedEvent(
User user,
string key,
string reason,
DomainModel sender)
: base(user,
sender)
{
Key = key;
Reason = reason;
}
public static Address AssembleAddress(DomainModel.Address address)
{
Address dto = new Address();
dto.Id = (int)(address.Id[0]);
dto.Street = address.Street;
dto.City = address.City;
dto.Email = address.Email;
dto.Postalcode = address.PostalCode;
dto.Phone = address.Phone;
dto.Timestamp = address.Timestamp.Value;
return dto;
}
public async Task<IEnumerable<ColumnLevelMetadata>> GetColumnMetadataFromFile(DomainModel.File fileDetail)
{
//throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Cannot get sheet details for file {0}", fileDetail.Name));
Check.IsNotNull<DomainModel.File>(fileDetail, "fileDetail");
List<ColumnLevelMetadata> columnLevelMetadataList = new List<ColumnLevelMetadata>();
await Task.Factory.StartNew(() =>
{
columnLevelMetadataList = new List<ColumnLevelMetadata>();
});
return columnLevelMetadataList;
}
private ServiceContract CreateServiceContractModel()
{
scStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(ServiceContractDslDomainModel));
scDomainModel = scStore.GetDomainModel<ServiceContractDslDomainModel>();
scTransaction = scStore.TransactionManager.BeginTransaction();
scModel = (ServiceContractModel)scDomainModel.CreateElement(new Partition(scStore), typeof(ServiceContractModel), null);
scModel.ImplementationTechnology = new ServiceContractWCFExtensionProvider();
scModel.ProjectMappingTable = projectMappingTableName;
ServiceContract sc = scStore.ElementFactory.CreateElement(ServiceContract.DomainClassId) as ServiceContract;
sc.Name = serviceContractName;
scModel.ServiceContracts.Add(sc);
return sc;
}
public async Task<IEnumerable<Utilities.Model.FileSheet>> GetDocumentSheetDetails(DomainModel.File fileDetail)
{
//throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Cannot get sheet details for file {0}", fileDetail.Name));
Check.IsNotNull<DomainModel.File>(fileDetail, "fileDetail");
List<FileSheet> fileSheets = new List<FileSheet>();
await Task.Factory.StartNew(() =>
{
string fileName = Path.GetFileNameWithoutExtension(fileDetail.Name);
fileSheets.Add(new FileSheet()
{
SheetName = fileName,
SheetId = fileName
});
});
return fileSheets;
}
// public static Role AssembleRole(DomainModel.Person.PersonRole role)
// {
// return (Role)Enum.Parse(typeof(Role), role.ToString(), true);
// }
public static Order AssembleOrder(DomainModel.Order order)
{
Order dto = new Order();
dto.OrderDate = order.OrderDate;
dto.ShippedDate = order.ShippedDate;
dto.Timestamp = order.Timestamp.Value;
ICollection orderDetails = order.OrderDetails;
dto.OrderDetails = new OrderDetail[orderDetails.Count];
IEnumerator detailEnum = orderDetails.GetEnumerator();
for(int i = 0; i < orderDetails.Count; i++)
{
detailEnum.MoveNext();
dto.OrderDetails[i] =
AssembleOrderDetail((DomainModel.OrderDetail)detailEnum.Current);
}
return dto;
}
public void TestInitialize()
{
serviceProvider = new MockMappingServiceProvider();
attributes = new NameValueCollection();
attributes.Add("elementNameProperty", "Name");
#region Data Contract
dcStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(DataContractDslDomainModel));
dcDomainModel = dcStore.GetDomainModel<DataContractDslDomainModel>();
dcTransaction = dcStore.TransactionManager.BeginTransaction();
dcModel = (DataContractModel)dcDomainModel.CreateElement(new Partition(dcStore), typeof(DataContractModel), null);
dcModel.ProjectMappingTable = projectMappingTableName;
dc = dcStore.ElementFactory.CreateElement(DataContract.DomainClassId) as DataContract;
primitiveDataElement = dcStore.ElementFactory.CreateElement(PrimitiveDataType.DomainClassId) as PrimitiveDataType;
primitiveDataElement.Name = primitiveDataElementName;
dc.DataMembers.Add(primitiveDataElement);
dcModel.Contracts.Add(dc);
#endregion
#region Service Contract
scStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(ServiceContractDslDomainModel));
scDomainModel = scStore.GetDomainModel<ServiceContractDslDomainModel>();
scTransaction = scStore.TransactionManager.BeginTransaction();
scModel = (ServiceContractModel)scDomainModel.CreateElement(new Partition(scStore), typeof(ServiceContractModel), null);
scModel.ProjectMappingTable = projectMappingTableName;
msg = scStore.ElementFactory.CreateElement(Message.DomainClassId) as Message;
msg.Name = messageName;
//Create the moniker
//mel://[DSLNAMESPACE]\[MODELELEMENTTYPE]\[MODELELEMENT.GUID]@[PROJECT]\[MODELFILE]
string requestMoniker = string.Format(@"mel://{0}\{1}\{2}@{3}\{4}",
primitiveDataElement.GetType().Namespace,
primitiveDataElement.GetType().Name,
primitiveDataElement.Id.ToString(),
dataContractModelProjectName, dataContractModelFileName);
part = scStore.ElementFactory.CreateElement(DataContractMessagePart.DomainClassId) as DataContractMessagePart;
part.Name = partName;
part.Type = new MockModelBusReference(primitiveDataElement);
msg.MessageParts.Add(part);
scModel.Messages.Add(msg);
#endregion
}
public async Task<IEnumerable<ColumnLevelMetadata>> GetColumnMetadataFromFile(DomainModel.File fileDetail)
{
Check.IsNotNull<DomainModel.File>(fileDetail, "fileDetail");
IEnumerable<ColumnLevelMetadata> columnLevelMetadataList = new List<ColumnLevelMetadata>();
await Task.Factory.StartNew(() =>
{
var fileArray = base.GetFileContentsAsByteArray(fileDetail.BlobId);
SpreadsheetDocument excelDocument;
using (var documentStream = new MemoryStream(fileArray))
{
excelDocument = SpreadsheetDocument.Open(documentStream, false);
columnLevelMetadataList = ExcelFileHelper.GetColumnMetadataForAllSheets(excelDocument);
}
});
return columnLevelMetadataList;
}
public ResponseModel Get()
{
//DomainModel db = new DomainModel();
List<Basic_Information> students;
using (var db = new DomainModel())
{
students = db.Basic_Information.ToList();
//students = db.Basic_Information.ToList();
}
ResponseModel response = new ResponseModel()
{
Issucces = true,
Message = "Data",
Data = students
};
return response;
}
public async Task<IEnumerable<ColumnLevelMetadata>> GetColumnMetadataFromFile(DomainModel.File fileDetail)
{
Check.IsNotNull<DomainModel.File>(fileDetail, "fileDetail");
IEnumerable<ColumnLevelMetadata> columnLevelMetadataList = new List<ColumnLevelMetadata>();
await Task.Factory.StartNew(() =>
{
using (Stream dataStream = base.BlobDataRepository.GetBlob(fileDetail.BlobId))
{
using (StreamReader reader = new StreamReader(new MemoryStream()))
{
// copy stream to input stream on the reader to parse content
dataStream.Seek(0, SeekOrigin.Begin);
dataStream.CopyToStream(reader.BaseStream);
// seek the begening of content
reader.BaseStream.Seek(0, SeekOrigin.Begin);
string fileName = Path.GetFileNameWithoutExtension(fileDetail.Name);
List<string> headers = new List<string>();
List<string> dataElements = new List<string>();
// iterate over each record in the data file
if (reader.Peek() >= 0)
{
// read the current line
string dataRow = reader.ReadLine();
headers = dataRow.Split(',').Select(e => e.Trim()).ToList();
////if (reader.Peek() >= 0)
////{
//// dataRow = reader.ReadLine();
//// dataElements = dataRow.Split(',').Select(e => e.Trim()).ToList();
////}
}
columnLevelMetadataList = CreateColumnLevelMetadataList(fileName, headers);
}
}
});
return columnLevelMetadataList;
}
public override void CaseApplication(DomainModel.Ast.Application x)
{
Contract.Requires(x != null);
Contract.Ensures(Contract.OldValue(ApplicationScope.Count) == ApplicationScope.Count);
Contract.Requires(SymbolTable != null);
Contract.RequiresAlways(!String.IsNullOrEmpty(x.ProperName));
Contract.Ensures(SymbolTable.Applications.Count >= Contract.OldValue(SymbolTable.Applications.Count));
if (x == null)
throw new ArgumentNullException("x");
if (string.IsNullOrEmpty(x.ProperName))
throw new ArgumentException("x.ProperName");
if (SymbolTable.Applications.ContainsKey(x.ProperName))
{
SymbolTable.AddError("(unknown location) Duplicate application definition for {0}", x.ProperName);
}
if (BasesIncludesSelf(x))
{
SymbolTable.AddError("{0} cannot derive from itself", x.ProperName);
}
if (ArtefactDerivesFromAnEnclosingScopeArtefact(x, () => ApplicationScope.Cast<ArtefactBase>()))
{
SymbolTable.AddError("{0} cannot derive from an enclosing scope application", x.ProperName);
}
ApplicationScope.Push(x);
foreach (var subArtefact in x.Applications)
{
subArtefact.Visit(this);
}
bool allDependenciesAreKnown = x.Dependencies.All(i => IsKnownReference(i, () => SymbolTable.Applications.Values.Cast<ArtefactBase>()));
if (!allDependenciesAreKnown)
{
SymbolTable.AddError("Application {0} declares a dependency that has not been defined previously", x.ProperName);
}
ApplicationScope.Pop();
SymbolTable.RaiseNewApplicationEvent(x);
}
public void TestInitialize()
{
serviceProvider = new MockMappingServiceProvider();
scStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(ServiceContractDslDomainModel));
scDomainModel = scStore.GetDomainModel<ServiceContractDslDomainModel>();
scTransaction = scStore.TransactionManager.BeginTransaction();
scModel = (ServiceContractModel)scDomainModel.CreateElement(new Partition(scStore), typeof(ServiceContractModel), null);
scModel.ImplementationTechnology = new ServiceContractWCFExtensionProvider();
scModel.ProjectMappingTable = projectMappingTableName;
ServiceContract sc = scStore.ElementFactory.CreateElement(ServiceContract.DomainClassId) as ServiceContract;
sc.Name = serviceContractName;
scModel.ServiceContracts.Add(sc);
hdStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(HostDesignerDomainModel));
hdDomainModel = hdStore.GetDomainModel<HostDesignerDomainModel>();
hdTransaction = hdStore.TransactionManager.BeginTransaction();
hdModel = (HostDesignerModel)hdDomainModel.CreateElement(new Partition(hdStore), typeof(HostDesignerModel), null);
HostApplication app = (HostApplication)hdStore.ElementFactory.CreateElement(HostApplication.DomainClassId);
app.ImplementationTechnology = new HostDesignerWcfExtensionProvider();
reference = (ServiceReference)hdStore.ElementFactory.CreateElement(ServiceReference.DomainClassId);
//mel://[DSLNAMESPACE]\[MODELELEMENTTYPE]\[MODELELEMENT.GUID]@[PROJECT]\[MODELFILE]
string serviceMoniker = string.Format(@"mel://{0}\{1}\{2}@{3}\{4}",
sc.GetType().Namespace,
serviceContractName,
sc.Id.ToString(),
serviceContractModelProjectName, serviceContractModelFileName);
reference.Name = serviceMelReferenceName;
reference.ServiceImplementationType = new MockModelBusReference(sc);
app.ServiceDescriptions.Add(reference);
// Initialize validator's config
attributes = new NameValueCollection();
attributes.Add("elementNameProperty", "Name");
}
public RouteSpecification(DomainModel.Potential.Location.Location origin, DomainModel.Potential.Location.Location destination, DateTime arrivalDeadline)
{
if (origin == null)
{
throw new ArgumentNullException("origin");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
if (origin == destination)
{
throw new ArgumentException("Origin and destination can't be the same.");
}
_origin = origin;
_arrivalDeadline = arrivalDeadline;
_destination = destination;
}
public void TestInitialize()
{
serviceProvider = new MockMappingServiceProvider();
attributes = new NameValueCollection();
attributes.Add("elementNameProperty", "Name");
#region Data Contract
dcStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(DataContractDslDomainModel));
dcDomainModel = dcStore.GetDomainModel<DataContractDslDomainModel>();
dcTransaction = dcStore.TransactionManager.BeginTransaction();
dcModel = (DataContractModel)dcDomainModel.CreateElement(new Partition(dcStore), typeof(DataContractModel), null);
dcModel.ProjectMappingTable = projectMappingTableName;
fc = dcStore.ElementFactory.CreateElement(FaultContract.DomainClassId) as FaultContract;
fc.Name = faultContractName;
dcModel.Contracts.Add(fc);
#endregion
#region Service Contract
scStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(ServiceContractDslDomainModel));
scDomainModel = scStore.GetDomainModel<ServiceContractDslDomainModel>();
scTransaction = scStore.TransactionManager.BeginTransaction();
scModel = (ServiceContractModel)scDomainModel.CreateElement(new Partition(scStore), typeof(ServiceContractModel), null);
scModel.ProjectMappingTable = projectMappingTableName;
operation = scStore.ElementFactory.CreateElement(Operation.DomainClassId) as Operation;
operation.Name = operationName;
//Create the moniker
//mel://[DSLNAMESPACE]\[MODELELEMENTTYPE]\[MODELELEMENT.GUID]@[PROJECT]\[MODELFILE]
string requestMoniker = string.Format(@"mel://{0}\{1}\{2}@{3}\{4}",
fc.GetType().Namespace,
fc.GetType().Name,
fc.Id.ToString(),
dataContractModelProjectName, dataContractModelFileName);
dcfault = scStore.ElementFactory.CreateElement(DataContractFault.DomainClassId) as DataContractFault;
dcfault.Name = dcfaultName;
dcfault.Type = new MockModelBusReference(fc);
operation.Faults.Add(dcfault);
scModel.Operations.Add(operation);
#endregion
}
public void DeleteExam(DomainModel.Exam exam)
{
Contract.Requires<ArgumentNullException>(exam != null, "The exam must be non-null!");
using (var context = new SchoolContext())
{
context.Exams.Attach(exam);
context.Exams.Remove(exam);
if (context.SaveChanges() != 0)
{
/*
Logger.Write("The exam " + exam + " was successfully removed!", "General", 2, 2, TraceEventType.Information);
* */
}/*
else
{
Logger.Write("The exam " + exam + " was not removed!", "Important", 1, 1, TraceEventType.Error);
}*/
}
}
public void AddExam(DomainModel.Exam exam)
{
using (var context = new SchoolContext())
{
context.Exams.Add(exam);
if (context.SaveChanges() != 0)
{
/*
if (Logger.IsLoggingEnabled())
{
Logger.Write("The exam: " + exam + " has been successfully added!", "General", 2, 2, TraceEventType.Information);
}*/
} /*
else
{
if (Logger.IsLoggingEnabled())
{
Logger.Write("The exam: " + exam + " insertion has failed!", "Important", 1, 1, TraceEventType.Error);
}
}*/
}
}
