public async Task IWireMockAdminApi_PostMappingAsync()
        {
            // Arrange
            var server = WireMockServer.StartWithAdminInterface();
            var api    = RestClient.For <IWireMockAdminApi>(server.Urls[0]);

            // Act
            var model = new MappingModel
            {
                Request = new RequestModel {
                    Path = "/1"
                },
                Response = new ResponseModel {
                    Body = "txt", StatusCode = 200
                },
                Priority = 500,
                Title    = "test"
            };
            var result = await api.PostMappingAsync(model);

            // Assert
            Check.That(result).IsNotNull();
            Check.That(result.Status).IsNotNull();
            Check.That(result.Guid).IsNotNull();

            var mapping = server.Mappings.Single(m => m.Priority == 500);

            Check.That(mapping).IsNotNull();
            Check.That(mapping.Title).Equals("test");

            server.Stop();
        }
        public string EditMapping(MappingModel model)
        {
            string table_Name    = model.Table_Name;
            string FormID        = model.FormID;
            int    Approved      = model.Approved;
            int    MappingFormID = model.MappingFormID;
            string Message       = "OK";

            using (SysContext db = new SysContext())
            {
                try
                {
                    fl_MappingForm entity_fl_MappingForm = db.fl_MappingForm.Single(d => d.MappingFormID == MappingFormID);
                    if (entity_fl_MappingForm != null)
                    {
                        entity_fl_MappingForm.FormNo       = FormID;
                        entity_fl_MappingForm.Table_Name   = table_Name;
                        entity_fl_MappingForm.Approved     = Approved;
                        entity_fl_MappingForm.ModifiedUser = LoginInfo.UserID;
                        entity_fl_MappingForm.ModifiedTime = DateTime.Now;
                        entity_fl_MappingForm.ResetUpdated();
                        db.SaveChanges();
                    }
                }
                catch
                {
                    Message = "Error";
                }
            }

            return(Message);
        }
        private MappingModel GetAuthMapping()
        {
            var mapping = new MappingModel
            {
                Guid    = Guid.Parse("425db3ef-06ca-4a69-b5c9-a9384cabc34e"),
                Title   = "Post Authentication",
                Request = new RequestModel
                {
                    Methods = new[] { "Post" },
                    Path    = JObject.Parse(
                        "{\"Matchers\": [{\"Name\": \"WildcardMatcher\",\"Pattern\": \"/login/v1/oauth2/token\",\"IgnoreCase\": true}]}")
                },
                Response = new ResponseModel
                {
                    StatusCode = 200,
                    BodyAsJson = new Token
                    {
                        AccessToken = "access_token",
                        ExpiresIn   = "20",
                        TokenType   = "token_type"
                    }
                }
            };

            return(mapping);
        }
Beispiel #4
0
 public void Post(MappingModel model)
 {
     try
     {
         if (string.IsNullOrWhiteSpace(model.MappingId))
         {
             _mappingManager.CreateMapping(model);
         }
         else
         {
             _mappingManager.UpdateMapping(model);
         }
     }
     catch (WebException exception)
     {
         LogHelper.Error(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception);
         throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest,
                                                                     exception.Message + " Please check your credentials"));
     }
     catch (Exception exception)
     {
         LogHelper.Error(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception);
         throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, exception.Message));
     }
 }
        public HttpResponseMessage SaveRedirect(MappingModel model)
        {
            var map = new Mapping();

            map.SourceUrl = model.SourceUrl.Trim();
            if (!string.IsNullOrEmpty(model.TargetUrl))
            {
                map.TargetUrl = model.TargetUrl;
            }
            else if (model.TargetTabId > 0)
            {
                map.TargetTabId = model.TargetTabId;
                map.TargetUrl   = DotNetNuke.Common.Globals.NavigateURL(map.TargetTabId, PortalSettings, "");
            }
            else
            {
                // keep giving 404
                map.EnableLogging = false;
            }
            if (map != null)
            {
                map.UseRegex = false;
                var cfg = RedirectConfig.Instance;
                cfg.Mappings.Add(map);
                cfg.ToFile(Common.RedirectConfigFile());
                RedirectConfig.Reload(PortalSettings.PortalId);
            }

            // set handledon/handledby in table
            RedirectController.SetHandledUrl(model.SourceUrl);

            return(Request.CreateResponse(HttpStatusCode.OK, new {}));
        }
Beispiel #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="templateMapping"></param>
        /// <returns></returns>
        private MappingModel MapAddMappingModel(TemplateMapping templateMapping)
        {
            var addCmsMappingModel = new MappingModel
            {
                GcTemplate = new GcTemplateModel
                {
                    Id = templateMapping.GcTemplate.GcTemplateId,
                },
                CmsTemplate = new CmsTemplateModel
                {
                    Id = templateMapping.CmsTemplate.TemplateId,
                },
                MappingTitle         = templateMapping.MappingTitle,
                DefaultLocationId    = templateMapping.DefaultLocationId,
                DefaultLocationTitle = templateMapping.DefaultLocationTitle
            };

            if (templateMapping.FieldMappings != null)
            {
                foreach (var fieldMapping in templateMapping.FieldMappings)
                {
                    addCmsMappingModel.FieldMappings.Add(new FieldMappingModel
                    {
                        CmsTemplateId = fieldMapping.CmsField.TemplateField.FieldId,
                        GcFieldId     = fieldMapping.GcField.Id,
                        GcFieldName   = fieldMapping.GcField.Name
                    });
                }
            }

            return(addCmsMappingModel);
        }
Beispiel #7
0
        public TFSSettingViewModel(ITFSSettingView view, IUriHelpView uriHelpView)
            : base(view)
        {
            if (uriHelpView == null)
            {
                throw new ArgumentNullException("uriHelpView");
            }

            this.uriHelpView = uriHelpView;

            this.uriHelpCommand = new DelegateCommand(OpenUriHelpCommandExcute);

            this.propertyMappingCollection = new PropertyMappingDictionary();
            this.tfsFields       = new ObservableCollection <TFSField>();
            this.bugFilterFields = new ObservableCollection <TFSField>();
            this.priorityValues  = new ObservableCollection <CheckString>();

            PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(typeof(Bug));

            foreach (PropertyDescriptor propertyDescriptor in propertyDescriptorCollection)
            {
                if (propertyDescriptor.Name == "Type")
                {
                    continue;
                }

                var mapping = new MappingModel(propertyDescriptor.Name);
                this.propertyMappingCollection.Add(mapping);

                AddWeakEventListener(mapping, PropertyMappingModelPropertyChanged);
            }

            ClearMappingData();
        }
        private ResponseMessage MappingsPost(RequestMessage requestMessage)
        {
            try
            {
                MappingModel mappingModel = requestMessage.Body != null?JsonConvert.DeserializeObject <MappingModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject <MappingModel>();

                DeserializeAndAddOrUpdateMapping(mappingModel);
            }
            catch (ArgumentException a)
            {
                Log.Error("HttpStatusCode set to 400", a);
                return(new ResponseMessage {
                    StatusCode = 400, Body = a.Message
                });
            }
            catch (Exception e)
            {
                Log.Error("HttpStatusCode set to 500", e);
                return(new ResponseMessage {
                    StatusCode = 500, Body = e.ToString()
                });
            }

            return(new ResponseMessage {
                StatusCode = 201, Body = "Mapping added"
            });
        }
        public void GeneralSettingDocumentTest()
        {
            MappingModel mappingModel = new MappingModel("ID");

            Assert.AreEqual("ID", mappingModel.Key);
            Assert.AreEqual(string.Empty, mappingModel.Value);
        }
Beispiel #10
0
        private void MatchTree_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
        {
            TreeView      treeView = (TreeView)sender;
            MatchTreeNode treeItem = (MatchTreeNode)treeView.SelectedItem;

            ((MatchTree)DataContext).SelectedNode = treeItem;


            MappingModel MappingModel = ((MatchTree)treeItem.Root).MappingModel;

            // Redraw both trees. Use property name like "CanMatch" or String.Empty for all properties (but it does not work because selection is also updated)
            MappingModel.SourceTree.NotifyAllOnPropertyChanged("CanMatch");
            MappingModel.TargetTree.NotifyAllOnPropertyChanged("CanMatch");

            MappingModel.SourceTree.NotifyAllOnPropertyChanged("IsMatched");
            MappingModel.TargetTree.NotifyAllOnPropertyChanged("IsMatched");

            this.UpdateLayout();
            this.UpdateLayout();

            treeView.UpdateLayout();
            treeView.UpdateLayout();

            // treeView.Items.Refresh(); // Error: stack overflow

            //GetBindingExpression(TreeView.ItemsSourceProperty).UpdateTarget();

            //ForceUIToUpdate();
            //this.OnPropertyChanged("IsSelected");
        }
Beispiel #11
0
        public string AddMapping(MappingModel model)
        {
            string table_Name = model.Table_Name;
            string FormID     = model.FormID;
            int    Approved   = model.Approved;
            string Message    = "OK";

            using (SysContext db = new SysContext())
            {
                System.Data.Entity.DbContextTransaction tran = db.Database.BeginTransaction();
                try
                {
                    fl_MappingForm entity_fl_MappingForm = new fl_MappingForm();
                    entity_fl_MappingForm.FormNo       = FormID;
                    entity_fl_MappingForm.Table_Name   = table_Name;
                    entity_fl_MappingForm.Approved     = Approved;
                    entity_fl_MappingForm.ApprovedDate = DateTime.Now;
                    entity_fl_MappingForm.TemplateUrl  = "";
                    entity_fl_MappingForm.CreatedUser  = LoginInfo.UserID;
                    entity_fl_MappingForm.ModifiedUser = LoginInfo.UserID;
                    entity_fl_MappingForm.ResetCreated();
                    db.fl_MappingForm.Add(entity_fl_MappingForm);
                    db.SaveChanges();
                    tran.Commit();
                }
                catch
                {
                    tran.Rollback();
                    Message = "Error";
                }
            }

            return(Message);
        }
 public IHttpActionResult Post(MappingModel model)
 {
     try
     {
         if (string.IsNullOrWhiteSpace(model.MappingId))
         {
             _mappingManager.CreateMapping(model);
         }
         else
         {
             _mappingManager.UpdateMapping(model);
         }
         return(Ok());
     }
     catch (WebException exception)
     {
         LogHelper.Error(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception);
         return(BadRequest(exception.Message + " Please check your credentials"));
     }
     catch (Exception exception)
     {
         LogHelper.Error(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception);
         return(BadRequest(exception.Message));
     }
 }
Beispiel #13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="model"></param>
        public void UpdateMapping(MappingModel model)
        {
            var template = FactoryService.Services.TemplateService.GetSingleTemplate(model.GcTemplate.Id);
            var project  = FactoryService.Services.ProjectsService.GetSingleProject(template.Data.ProjectId.ToString());

            var templateMapping = new TemplateMapping
            {
                MappingId         = model.MappingId,
                MappingTitle      = model.MappingTitle,
                DefaultLocationId = model.DefaultLocationId,
                LastUpdatedDate   = template.Data.Updated.ToString(),
                GcProjectId       = project.Data.Id.ToString(),
                GcProjectName     = project.Data.Name,
                CmsTemplate       = new CmsTemplate
                {
                    TemplateId = model.CmsTemplate.Id
                },
                GcTemplate = new GcTemplate
                {
                    GcTemplateId   = template.Data.Id.ToString(),
                    GcTemplateName = template.Data.Name
                },
            };

            var fieldMappings = ConvertToFieldMappings(model.FieldMappings);

            templateMapping.FieldMappings = fieldMappings;
            FactoryRepository.Repositories.MappingRepository.UpdateMapping(templateMapping);
        }
 /// <summary>
 /// Creates a new Repository with the table name and maps passed directly into the contructor.
 /// </summary>
 /// <param name="dbAdapter">DbAdapter class for the database being used</param>
 /// <param name="tableName">Name of the table</param>
 /// <param name="maps">List of maps for this tabe</param>
 public DbRepository(IDbAdapter dbAdapter, string tableName, IEnumerable <IMap> maps)
 {
     DbAdapter        = dbAdapter;
     ConnectionString = dbAdapter.ConnectionString;
     TableName        = tableName;
     Mappings         = new MappingModel <T>(maps);
 }
 /// <summary>
 /// Creates a new Repository using an EntityMap to define the database mapping.
 /// </summary>
 /// <param name="dbAdapter">DbAdapter class for the database being used</param>
 /// <param name="entityMap">Entity map class used to define the mapping for this repository</param>
 public DbRepository(IDbAdapter dbAdapter, EntityMap <T> entityMap)
 {
     DbAdapter        = dbAdapter;
     ConnectionString = dbAdapter.ConnectionString;
     TableName        = entityMap.TableName;
     Mappings         = new MappingModel <T>(entityMap);
 }
        public List <MappingModel> GetMappingModel()
        {
            var mappings = MappingRepository.GetMappings();

            var model = new List <MappingModel>();

            foreach (var templateMapping in mappings)
            {
                var mappingModel = new MappingModel
                {
                    GcProject = new GcProjectModel
                    {
                        Name = templateMapping.GcProjectName
                    },
                    GcTemplate = new GcTemplateModel
                    {
                        Id   = templateMapping.GcTemplate.GcTemplateId,
                        Name = templateMapping.GcTemplate.GcTemplateName,
                    },
                    CmsTemplate = new CmsTemplateModel
                    {
                        Name = templateMapping.CmsTemplate.TemplateName,
                    },
                    MappingId          = templateMapping.MappingId,
                    MappingTitle       = templateMapping.MappingTitle,
                    LastMappedDateTime = templateMapping.LastMappedDateTime,
                    LastUpdatedDate    = templateMapping.LastUpdatedDate,
                };
                model.Add(mappingModel);
            }

            foreach (var mapping in model)
            {
                try
                {
                    var template = GetGcTemplateEntity(mapping.GcTemplate.Id);
                    if (template == null)
                    {
                        mapping.LastUpdatedDate = "Removed from GatherContent";
                    }
                    else
                    {
                        var gcUpdateDate = ConvertMsecToDate((double)template.Data.Updated);
                        var dateFormat   = AccountSettings.DateFormat;
                        if (string.IsNullOrEmpty(dateFormat))
                        {
                            dateFormat = Constants.DateFormat;
                        }
                        mapping.LastUpdatedDate = gcUpdateDate.ToString(dateFormat);
                    }
                }
                catch (Exception)
                {
                    mapping.LastUpdatedDate = "Removed from GatherContent";
                }
            }

            return(model);
        }
        private async Task AddMapping(MappingModel model)
        {
            var api    = RestClient.For <IWireMockAdminApi>(new Uri(_settings.OdsApiWireMockBaseUrl));
            var result = await api.PostMappingAsync(model);

            result.Status.Should().Be("Mapping added");
            _context[ScenarioContextKeys.MappingAdded] = true;
        }
        private Guid?ConvertMappingAndRegisterAsRespondProvider(MappingModel mappingModel, Guid?guid = null, string path = null)
        {
            Check.NotNull(mappingModel, nameof(mappingModel));
            Check.NotNull(mappingModel.Request, nameof(mappingModel.Request));
            Check.NotNull(mappingModel.Response, nameof(mappingModel.Response));

            var requestBuilder = InitRequestBuilder(mappingModel.Request, true);

            if (requestBuilder == null)
            {
                return(null);
            }

            var responseBuilder = InitResponseBuilder(mappingModel.Response);

            var respondProvider = Given(requestBuilder, mappingModel.SaveToFile == true);

            if (guid != null)
            {
                respondProvider = respondProvider.WithGuid(guid.Value);
            }
            else if (mappingModel.Guid != null && mappingModel.Guid != Guid.Empty)
            {
                respondProvider = respondProvider.WithGuid(mappingModel.Guid.Value);
            }

            if (path != null)
            {
                respondProvider = respondProvider.WithPath(path);
            }

            if (!string.IsNullOrEmpty(mappingModel.Title))
            {
                respondProvider = respondProvider.WithTitle(mappingModel.Title);
            }

            if (mappingModel.Priority != null)
            {
                respondProvider = respondProvider.AtPriority(mappingModel.Priority.Value);
            }

            if (mappingModel.Scenario != null)
            {
                respondProvider = respondProvider.InScenario(mappingModel.Scenario);
                respondProvider = respondProvider.WhenStateIs(mappingModel.WhenStateIs);
                respondProvider = respondProvider.WillSetStateTo(mappingModel.SetStateTo);
            }

            if (mappingModel.Webhook?.Request != null)
            {
                respondProvider = respondProvider.WithWebhook(WebhookMapper.Map(mappingModel.Webhook));
            }

            respondProvider.RespondWith(responseBuilder);

            return(respondProvider.Guid);
        }
Beispiel #19
0
        private static async Task AddMapping(MappingModel model)
        {
            model.Guid     = Guid.NewGuid();
            model.Priority = 10;
            var api    = RestClient.For <IWireMockAdminApi>(new Uri(WireMockBaseUrl));
            var result = await api.PostMappingAsync(model).ConfigureAwait(false);

            result.Status.Should().Be("Mapping added");
        }
        public HttpResponseMessage SaveMapping(MappingModel model) // string id, bool useRegex, string sourceUrl, string targetUrl, int targetTabId)
        {
            var map = RedirectConfig.Instance.Mappings.FirstOrDefault(m => m.Id == model.Id);

            if (!string.IsNullOrEmpty(model.Id) && map == null)
            {
                return(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            if (map == null && string.IsNullOrEmpty(model.Id))
            {
                map    = new Mapping();
                map.Id = Guid.NewGuid().ToString();
                RedirectConfig.Instance.Mappings.Add(map);
            }

            map.StatusCode    = model.StatusCode;
            map.SourceUrl     = model.SourceUrl.Trim();
            map.UseRegex      = model.UseRegex;
            map.EnableLogging = model.EnableLogging;
            if (!string.IsNullOrEmpty(model.TargetUrl))
            {
                map.TargetTabId = Null.NullInteger;
                map.TargetUrl   = model.TargetUrl;
            }
            else if (model.TargetTabId > 0)
            {
                map.TargetTabId = model.TargetTabId;
                map.TargetUrl   = DotNetNuke.Common.Globals.NavigateURL(map.TargetTabId, PortalSettings, "");
            }
            else if (model.TargetTabId == -1) // matches with number in js file
            {
                map.TargetTabId = model.TargetTabId;
                map.TargetUrl   = "";
            }
            else if (model.TargetTabId == -2) // matches with number in js file, meaning it needs to be deleted
            {
                // remove mapping
                RedirectConfig.Instance.Mappings.Remove(map);
                map = null;
            }

            RedirectConfig.Instance.ToFile(Common.RedirectConfigFile());
            RedirectConfig.Reload(PortalSettings.PortalId);

            // set handledon/handledby in table
            if (!model.UseRegex)
            {
                RedirectController.SetHandledUrl(model.SourceUrl);
            }

            return(Request.CreateResponse(HttpStatusCode.OK, map == null ? null : new MappingModel(map)));
        }
        private ResponseMessage MappingPut(RequestMessage requestMessage)
        {
            Guid guid = Guid.Parse(requestMessage.Path.TrimStart(AdminMappings.ToCharArray()));

            MappingModel mappingModel = requestMessage.Body != null?JsonConvert.DeserializeObject <MappingModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject <MappingModel>();

            DeserializeAndAddOrUpdateMapping(mappingModel, guid);

            return(new ResponseMessage {
                Body = "Mapping added or updated"
            });
        }
Beispiel #22
0
        private Guid?DeserializeAndAddOrUpdateMapping(MappingModel mappingModel, Guid?guid = null, string path = null)
        {
            Check.NotNull(mappingModel, nameof(mappingModel));
            Check.NotNull(mappingModel.Request, nameof(mappingModel.Request));
            Check.NotNull(mappingModel.Response, nameof(mappingModel.Response));

            var requestBuilder = InitRequestBuilder(mappingModel.Request, true);

            if (requestBuilder == null)
            {
                return(null);
            }

            var responseBuilder = InitResponseBuilder(mappingModel.Response);

            var respondProvider = Given(requestBuilder);

            if (guid != null)
            {
                respondProvider = respondProvider.WithGuid(guid.Value);
            }
            else if (mappingModel.Guid != null && mappingModel.Guid != Guid.Empty)
            {
                respondProvider = respondProvider.WithGuid(mappingModel.Guid.Value);
            }

            if (path != null)
            {
                respondProvider = respondProvider.WithPath(path);
            }

            if (!string.IsNullOrEmpty(mappingModel.Title))
            {
                respondProvider = respondProvider.WithTitle(mappingModel.Title);
            }

            if (mappingModel.Priority != null)
            {
                respondProvider = respondProvider.AtPriority(mappingModel.Priority.Value);
            }

            if (mappingModel.Scenario != null)
            {
                respondProvider = respondProvider.InScenario(mappingModel.Scenario);
                respondProvider = respondProvider.WhenStateIs(mappingModel.WhenStateIs);
                respondProvider = respondProvider.WillSetStateTo(mappingModel.SetStateTo);
            }

            respondProvider.RespondWith(responseBuilder);

            return(respondProvider.Guid);
        }
Beispiel #23
0
        private void ShowMappingWindow(MappingModel mappingModel)
        {
            XmlElement newMapping = mConfiguration.ConfigXml.CreateElement(MappingName);

            IElementConfiguration elementConfiguration = new ElementConfiguration(mConfiguration, mappingModel.Node, newMapping);

            ElementWindow elementWindow = new ElementWindow(elementConfiguration,
                                                            DefinitionFactory.Create(MappingDescriptor.Mapping, elementConfiguration),
                                                            WindowSizeLocationFactory.Create(MappingDescriptor.Mapping),
                                                            new AddSaveStrategy <MappingModel>(mappingModel, model => Mappings.Add(model), newMapping));

            mMessageBoxService.ShowWindow(elementWindow);
        }
        public IActionResult Index(HomeModel model)
        {
            MappingModel mapModel            = new MappingModel();
            var          circumferencePoints = GetList(model.latitude, model.longitude, model.distance);
            Coordinates  coordinates         = new Coordinates();

            coordinates.lat = model.latitude;
            coordinates.lng = model.longitude;
            var populatedCoordinates = PopulatedCoordinates(circumferencePoints, false, coordinates);

            mapModel.CordinateList = Newtonsoft.Json.JsonConvert.SerializeObject(populatedCoordinates);
            return(View(mapModel));
        }
        public void PropertiesWithNotification()
        {
            MappingModel mappingModel = new MappingModel("ID");

            AssertHelper.PropertyChangedEvent(mappingModel, x => x.Value, () => mappingModel.Value = "ID");
            Assert.AreEqual("ID", mappingModel.Value);

            mappingModel.Value = null;
            Assert.AreEqual("ID", mappingModel.Value);

            AssertHelper.PropertyChangedEvent(mappingModel, x => x.Value, () => mappingModel.Value = string.Empty);
            Assert.AreEqual(string.Empty, mappingModel.Value);
        }
        public void PropertiesWithNotification()
        {
            MappingModel mappingModel = new MappingModel("ID");

            AssertHelper.PropertyChangedEvent(mappingModel, x => x.Value, () => mappingModel.Value = "ID");
            Assert.AreEqual("ID", mappingModel.Value);

            mappingModel.Value = null;
            Assert.AreEqual("ID", mappingModel.Value);

            AssertHelper.PropertyChangedEvent(mappingModel, x => x.Value, () => mappingModel.Value = string.Empty);
            Assert.AreEqual(string.Empty, mappingModel.Value);
        }
Beispiel #27
0
 public static Mapping ToNewDbObject(this MappingModel mapping)
 {
     return(new Mapping
     {
         ApplicationId = mapping.ApplicationId,
         EnvironmentId = mapping.EnvironmentId,
         ParameterId = mapping.ParameterId,
         RegionId = mapping.RegionId,
         ServerId = mapping.ServerId,
         SuiteId = mapping.SuiteId,
         MappingId = mapping.MappingId
     });
 }
        public void XNamespace_returns_element_namespace_if_element_not_null()
        {
            var element = new XElement("{urn:tempuri}element");
            var modelManager = new Mock<ModelManager>(null, null).Object;
            var modelProvider = new Mock<XmlModelProvider>().Object;
            var entityDesignArtifactMock = new Mock<EntityDesignArtifact>(modelManager, new Uri("urn:dummy"), modelProvider);
            entityDesignArtifactMock.Setup(a => a.SchemaVersion).Returns(EntityFrameworkVersion.Version3);

            using (var mappingModel = new MappingModel(entityDesignArtifactMock.Object, element))
            {
                Assert.Same(element.Name.Namespace, mappingModel.XNamespace);
            }
        }
 /// <summary>
 /// Creates a new Repository using attributes to define the database mapping.
 /// All non-virtual properties with public getters and setters will be mapped
 /// unless overridden with an attribute.
 /// </summary>
 /// <param name="dbAdapter">DbAdapter class for the database being used</param>
 /// <param name="overrideTableName">Overrides the table name generated from the object name or the table attribute.</param>
 /// <param name="ignoreObjectMaps">Sets if properties that end with _Object or _Objects will be ignored by the automatic mapping</param>
 public DbRepository(IDbAdapter dbAdapter, string overrideTableName = null, bool ignoreObjectMaps = true)
 {
     DbAdapter        = dbAdapter;
     ConnectionString = dbAdapter.ConnectionString;
     if (string.IsNullOrWhiteSpace(overrideTableName))
     {
         TableName = GetTableName();
     }
     else
     {
         TableName = overrideTableName;
     }
     Mappings = new MappingModel <T>(ignoreObjectMaps);
 }
        public void ReadStaticMappingAndAddOrUpdate([NotNull] string path)
        {
            Check.NotNull(path, nameof(path));

            string filenameWithoutExtension = Path.GetFileNameWithoutExtension(path);

            MappingModel mappingModel = JsonConvert.DeserializeObject <MappingModel>(FileHelper.ReadAllText(path));

            if (Guid.TryParse(filenameWithoutExtension, out Guid guidFromFilename))
            {
                DeserializeAndAddOrUpdateMapping(mappingModel, guidFromFilename, path);
            }
            else
            {
                DeserializeAndAddOrUpdateMapping(mappingModel, null, path);
            }
        }
Beispiel #31
0
        private static async Task SendModel(MappingModel model, ScenarioContext context, string mappingKey)
        {
            await AddMapping(model).ConfigureAwait(false);

            if (!context.ContainsKey(mappingKey))
            {
                context[mappingKey] = new List <Guid>();
            }

            if (context[mappingKey] is List <Guid> guidList)
            {
                if (model.Guid != null)
                {
                    guidList.Add(model.Guid.Value);
                }
            }
        }
        public void WireMockServer_WithMappingAsModel_Should_Add_Mapping()
        {
            // Arrange
            var guid     = Guid.NewGuid();
            var pattern  = "hello wiremock";
            var path     = "/foo";
            var response = "OK";
            var mapping  = new MappingModel
            {
                Guid    = guid,
                Request = new RequestModel
                {
                    Path = path,
                    Body = new BodyModel
                    {
                        Matcher = new MatcherModel
                        {
                            Name    = "ExactMatcher",
                            Pattern = pattern
                        }
                    }
                },
                Response = new ResponseModel
                {
                    Body       = response,
                    StatusCode = 201
                }
            };

            var server = WireMockServer.Start();

            // Act
            server.WithMapping(mapping);

            // Assert
            server.MappingModels.Should().HaveCount(1).And.Contain(m =>
                                                                   m.Guid == guid &&
                                                                   //((PathModel)m.Request.Path).Matchers.OfType<WildcardMatcher>().First().GetPatterns().First() == "/foo*"
                                                                   // m.Request.Body.Matchers.OfType<ExactMatcher>().First().GetPatterns().First() == pattern &&
                                                                   m.Response.Body == response &&
                                                                   (int)m.Response.StatusCode == 201
                                                                   );

            server.Stop();
        }
        public void XNamespace_returns_root_namespace_if_element_null()
        {
            var tmpElement = new XElement("{http://schemas.microsoft.com/ado/2009/11/mapping/cs}Schema");

            var modelManager = new Mock<ModelManager>(null, null).Object;
            var modelProvider = new Mock<XmlModelProvider>().Object;
            var enityDesignArtifiact =
                new Mock<EntityDesignArtifact>(modelManager, new Uri("urn:dummy"), modelProvider)
                    {
                        CallBase = true
                    }.Object;

            enityDesignArtifiact.SetXObject(
                XDocument.Parse("<Edmx xmlns=\"http://schemas.microsoft.com/ado/2009/11/edmx\" />"));

            using (var mappingModel = new MappingModel(enityDesignArtifiact, tmpElement))
            {
                mappingModel.SetXObject(null);
                Assert.Equal("http://schemas.microsoft.com/ado/2009/11/mapping/cs", mappingModel.XNamespace);

                // resetting the element is required for clean up
                mappingModel.SetXObject(tmpElement);
            }
        }
 public virtual void ProcessCollection(MappingModel.Collections.CollectionMapping mapping)
 {
     
 }
        public virtual void Visit(MappingModel.Collections.CollectionMapping collectionMapping)
        {

        }
 public void GeneralSettingDocumentTest()
 {
     MappingModel mappingModel = new MappingModel("ID");
     Assert.AreEqual("ID", mappingModel.Key);
     Assert.AreEqual(string.Empty, mappingModel.Value);
 }
        protected override void OnChildDeleted(EFContainer efContainer)
        {
            if (efContainer == _designerInfoRoot)
            {
                _designerInfoRoot = null;
            }
            else if (efContainer == _mappingModel)
            {
                _mappingModel = null;
            }
            else if (efContainer == _conceptualEntityModel)
            {
                _conceptualEntityModel = null;
            }
            else if (efContainer == _storageEntityModel)
            {
                _storageEntityModel = null;
            }

            base.OnChildDeleted(efContainer);
        }
 internal EFRuntimeModelRoot CreateRuntimeModelRoot(XElement runtimeModelRoot)
 {
     if (runtimeModelRoot.Name.LocalName == BaseEntityModel.ElementName
         && CheckForCorrectNamespace(runtimeModelRoot, SchemaManager.GetCSDLNamespaceNames(), false))
     {
         if (_conceptualEntityModel != null)
         {
             _conceptualEntityModel.Dispose();
         }
         _conceptualEntityModel = new ConceptualEntityModel(this, runtimeModelRoot);
         return _conceptualEntityModel;
     }
     else if (runtimeModelRoot.Name.LocalName == BaseEntityModel.ElementName
              && CheckForCorrectNamespace(runtimeModelRoot, SchemaManager.GetSSDLNamespaceNames(), false))
     {
         if (_storageEntityModel != null)
         {
             _storageEntityModel.Dispose();
         }
         _storageEntityModel = new StorageEntityModel(this, runtimeModelRoot);
         return _storageEntityModel;
     }
     else if (runtimeModelRoot.Name.LocalName == MappingModel.ElementName
              && CheckForCorrectNamespace(runtimeModelRoot, SchemaManager.GetMSLNamespaceNames(), false))
     {
         if (_mappingModel != null)
         {
             _mappingModel.Dispose();
         }
         _mappingModel = new MappingModel(this, runtimeModelRoot);
         return _mappingModel;
     }
     else
     {
         //Debug.Fail("Unexpected runtime model root");
         return null;
     }
 }
        internal override void Parse(ICollection<XName> unprocessedElements)
        {
            State = EFElementState.ParseAttempted;

            var path = Uri.LocalPath;
            var lastdot = path.LastIndexOf('.');
            var extension = Uri.LocalPath.Substring(lastdot, path.Length - lastdot);

            if (extension.EndsWith(ExtensionMsl, StringComparison.OrdinalIgnoreCase))
            {
                _mappingModel = new MappingModel(this, XDocument.Root);
            }
            else if (extension.EndsWith(ExtensionCsdl, StringComparison.OrdinalIgnoreCase))
            {
                _conceptualEntityModel = new ConceptualEntityModel(this, XDocument.Root);
            }
            else if (extension.EndsWith(ExtensionSsdl, StringComparison.OrdinalIgnoreCase))
            {
                _storageEntityModel = new StorageEntityModel(this, XDocument.Root);
            }
            else if (GetFileExtensions().Contains(extension))
            {
                if (_designerInfoRoot != null)
                {
                    _designerInfoRoot.Dispose();
                    _designerInfoRoot = null;
                }

                if (_storageEntityModel != null)
                {
                    _storageEntityModel.Dispose();
                    _storageEntityModel = null;
                }

                if (_mappingModel != null)
                {
                    _mappingModel.Dispose();
                    _mappingModel = null;
                }

                if (_conceptualEntityModel != null)
                {
                    _conceptualEntityModel.Dispose();
                    _conceptualEntityModel = null;
                }

                // convert the xlinq tree to our model
                foreach (var elem in XObject.Document.Elements())
                {
                    ParseSingleElement(unprocessedElements, elem);
                }
            }

            if (_designerInfoRoot != null)
            {
                _designerInfoRoot.Parse(unprocessedElements);
            }

            if (_conceptualEntityModel != null)
            {
                _conceptualEntityModel.Parse(unprocessedElements);
            }

            if (_storageEntityModel != null)
            {
                _storageEntityModel.Parse(unprocessedElements);
            }

            if (_mappingModel != null)
            {
                _mappingModel.Parse(unprocessedElements);
            }

            State = EFElementState.Parsed;
        }
        protected override void Dispose(bool disposing)
        {
            try
            {
                if (disposing)
                {
                    if (_designerInfoRoot != null)
                    {
                        _designerInfoRoot.Dispose();
                        _designerInfoRoot = null;
                    }

                    if (_mappingModel != null)
                    {
                        _mappingModel.Dispose();
                        _mappingModel = null;
                    }

                    if (_conceptualEntityModel != null)
                    {
                        _conceptualEntityModel.Dispose();
                        _conceptualEntityModel = null;
                    }

                    if (_storageEntityModel != null)
                    {
                        _storageEntityModel.Dispose();
                        _storageEntityModel = null;
                    }

                    if (DiagramArtifact != null)
                    {
                        ModelManager.ClearArtifact(DiagramArtifact.Uri);
                        DiagramArtifact = null;
                    }
                }
            }
            finally
            {
                base.Dispose(disposing);
            }
        }