public void Submit(FBApi api, Mapping target)
        {
            Log.Verbose(LogCategory, "Submitting new or updated error information to server", null);

            // Start by looking for the fingerprint to decide whether we need
            // to create an new case or update an existing one.
            Dictionary<string, string> args = new Dictionary<string, string>
                           {
                               {"sScoutDescription", Error.Fingerprint},
                           };

            string results = api.Cmd("listScoutCase", args);
            XmlDocument xml = new XmlDocument();
            xml.LoadXml(results);
            XmlNode caseNode = xml.SelectSingleNode("/response/case/ixBug");

            if (caseNode == null)
            {
                Log.Information(LogCategory, "Submitting as new issue because no existing Scout Case could be found with the fingerprint", "Fingerprint: {0}\r\n\r\nRaw Result:\r\n{1}", Error.Fingerprint, results);
                SubmitNew(api, target);
            }
            else
            {
                Log.Information(LogCategory, "Submitting as an update because an existing Scout Case matched the fingerprint", "Fingerprint: {0}\r\n\r\nRaw Result:\r\n{1}", Error.Fingerprint, results);
                SubmitUpdate(api, caseNode.InnerText);
            }
        }

		public PocoComponentTuplizer(Mapping.Component component) : base(component)
		{
			componentClass = component.ComponentClass;

			var parentProperty = component.ParentProperty;
			if (parentProperty == null)
			{
				parentSetter = null;
				parentGetter = null;
			}
			else
			{
				parentSetter = parentProperty.GetSetter(componentClass);
				parentGetter = parentProperty.GetGetter(componentClass);
			}

			if (hasCustomAccessors || !Cfg.Environment.UseReflectionOptimizer)
			{
				optimizer = null;
			}
			else
			{
				optimizer = Cfg.Environment.BytecodeProvider.GetReflectionOptimizer(componentClass, getters, setters);
			}
		}

        public Interface(Mapping.Interface iface, DataCenter[] dataCenters = null, IpAddress[] ips = null)
        {
            this.Id = iface.Id;
            this.DataCenterId = iface.DataCenterId;
            if (dataCenters != null)
                this.DataCenter = dataCenters.SingleOrDefault(d => d.Id == iface.DataCenterId);
            this.Created = iface.Created;
            this.LastUpdated = iface.LastUpdated;
            if (iface.Num != null)
                this.Index = Convert.ToInt32(iface.Num);
            this.Status = Converter.ToInterfaceStatus(iface.State);
            this.Bandwidth = iface.Bandwidth;
            this.Type = Converter.ToInterfaceType(iface.Type);
            if (iface.VirtualMachineId != null)
                this.VirtualMachineId = Convert.ToInt32(iface.VirtualMachineId);
            this.VirtualMachine = null;
            this.IpAddressIds = iface.IpAddressIds;
            if (ips != null)
            {
                List<IpAddress> ipList = new List<IpAddress>();
                foreach (int ipId in iface.IpAddressIds)
                {
                    IpAddress ipAddress = ips.SingleOrDefault(i => i.Id == ipId);

                    if (ipAddress.Interface == null)
                        ipAddress.Interface = this;

                    ipList.Add(ipAddress);
                }
                this.IpAddresses = ipList.ToArray();
            }
        }

        public SqlMapperTransformer(Mapping mapping, Evaluant.Uss.Models.Model model)
        {
            _Mapping = mapping;
            _Model = model;
            _ExprLevel = new Stack();

            _AliasColumnMapping = new Hashtable();
            _IsAliasColumnComputed = false;

            // Add "Type" and "Id" field. Avoid duplicated field if mapping model contains these two keyword fields.
            //            _AliasColumnMapping.Add("Type", "Type");

            foreach (EntityMapping em in mapping.Entities)
            {
                if (em.DiscriminatorField == null || em.DiscriminatorField == string.Empty)
                    continue;

                if (_AliasColumnMapping.ContainsKey(em.DiscriminatorField))
                    continue;

                _AliasColumnMapping.Add(em.DiscriminatorField, em.DiscriminatorField);
            }

            //_AliasColumnMapping.Add("Id", "Id");
        }

        public SqlMapperPersistenceEngine(string connectionString, IDriver driver, DBDialect dialect, Mapping mapping, ArrayList cacheEntries, Models.Model model)
        {
            if (connectionString == null)
            {
                throw new ArgumentNullException("connectionString");
            }
            if (driver == null)
            {
                throw new ArgumentNullException("driver");
            }
            if (dialect == null)
            {
                throw new ArgumentNullException("dialect");
            }
            if (mapping == null)
            {
                throw new ArgumentNullException("mapping");
            }
            this.Driver = driver;
            this.Dialect = dialect;
            this._Mapping = mapping;
            this._Connection = this._Driver.CreateConnection(connectionString);

            if (_Connection is Evaluant.Uss.Data.FileClient.FileConnection)
            {
                ((Evaluant.Uss.Data.FileClient.FileConnection)_Connection).Dialect = dialect;
            }

            base._Model = model;
            this._CacheEntries = cacheEntries;
            this.Initialize();
        }

		static void Init()
		{
			string[] wrk = "C,D,E,F,G,H,I,J,K,L,M,N,O.P,Q,R,S,T,U,V,W,X,Y,Z,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O.P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,".Split(new char[] {','});
			mFS = new Mapping[wrk.Length];
			for (int i = 0; i < wrk.Length; i++) mFS[i] = new Mapping(wrk[i]);
			doneInit = true;
		}

        protected override string BuildTableScript(Mapping.IEntityMapping mapping)
        {
            var tableName = GetTableName(mapping);
            var sb = new StringBuilder(512);
            sb.Append("CREATE TABLE ").Append(tableName).Append("(");

            int num = 0;
            foreach (var f in mapping.Members.Where(p => !p.IsRelationship && !p.IsComputed))
            {
                if (num > 0)
                    sb.Append(",");
                sb.AppendLine();

                sb.Append("\t").Append(Dialect.Quote(f.ColumnName));

                var sqlType = f.SqlType;
                sb.Append(" ").Append(GetDbType(f.SqlType));

                if (sqlType.Required || f.IsPrimaryKey)
                    sb.Append(" NOT NULL");

                if (f.IsGenerated)
                    sb.Append(GetDefaultValue(f, sqlType));
                num++;
            }

            sb.AppendLine()
                .Append(")");
            sb.AppendLine("");
            return sb.ToString();
        }

        /// <summary>
        /// Add a specific resource.
        /// </summary>
        /// <param name="path">Path (Uri) requested by clients</param>
        /// <param name="assembly">Assembly that the resources exist in</param>
        /// <param name="rootNameSpace">Name space to root folder under (all name spaces below the specified one are considered as folders)</param>
        /// <param name="fullResourceName">Name space and name of resource.</param>
        /// <example>
        /// <code>
        /// Add("/", Assembly.GetExecutingAssembly(), "MyApplication.Files", "Myapplication.Files.Images.MyImage.png");
        /// </code>
        /// </example>
        public void Add(string path, Assembly assembly, string rootNameSpace, string fullResourceName)
        {
            if (!path.EndsWith("/"))
                path += "/";

            var mapping = new Mapping { Assembly = assembly, FullResourceName = fullResourceName };

            string filePath = fullResourceName.Remove(0, rootNameSpace.Length + 1);

            int extensionPos = filePath.LastIndexOf(".", StringComparison.Ordinal);
            if (extensionPos == -1)
                return;

            int nextPos = filePath.LastIndexOf(".", extensionPos - 1, StringComparison.Ordinal);
            if (nextPos != -1)
            {
                string typeExtension = filePath.Substring(nextPos + 1, extensionPos - nextPos - 1);
                if (typeExtension == "xml" || typeExtension == "json" || typeExtension == "js")
                    mapping.TypeExtension = typeExtension;
            }

            if (string.IsNullOrEmpty(mapping.TypeExtension))
                nextPos = extensionPos;

            // TODO: next thing is to set the language. But not today.
            // /users/list.1053.xml.spark <--- language 1053, view for xml, spark is the view engine.
            filePath = filePath.Substring(0, nextPos).Replace(".", "/") + filePath.Substring(extensionPos);

            mapping.FileName = Path.GetFileName(filePath).ToLower();
            mapping.UriPath = (path + filePath).Replace('\\', '/').ToLower();

            _logger.Trace("Adding mapping '" + path + filePath + "' to resource '" + fullResourceName + "' assembly '" + assembly + "'.");
            _mappings.Add(path.ToLower() + filePath.ToLower(), mapping);
        }

        public bool Execute(string directory, Mapping mapToRun, BuildData buildData)
        {
            try
            {
                DeploymentHost host = new DeploymentHost();
                Runspace space = RunspaceFactory.CreateRunspace(host);
                space.Open();

                this.PopulateVariables(space, mapToRun, buildData);

                string command = this.GeneratePipelineCommand(directory, mapToRun);
                this._scriptRun = command;

                this.EnsureExecutionPolicy(space);
                Pipeline pipeline = space.CreatePipeline(command);
                Collection<PSObject> outputObjects = pipeline.Invoke();

                if (pipeline.PipelineStateInfo.State != PipelineState.Failed)
                {
                    this._errorOccured = false;
                }

                string output = this.GenerateOutputFromObjects(outputObjects);
                this._output = output;

                space.Close();
            }
            catch (Exception ex)
            {
                this._errorOccured = true;
                this._output = ex.ToString();
            }

            return this.ErrorOccured;
        }

 public void mappings_can_be_added()
 {
     var converter = new MapConverter();
     var mapping = new Mapping("from", "to");
     converter.Mappings.Add(mapping);
     Assert.True(converter.Mappings.Contains(mapping));
 }

        public DialogResult AddMapping(Dictionary<string, List<String>> productsAndApplications, 
            Dictionary<string, List<String>> projectsAndAreas, 
            Dictionary<int, string> priorities, 
            out Mapping newMapping)
        {
            Text = AddMappingTitle;

            m_ProductsAndApplications = productsAndApplications;
            m_ProjectsAndAreas = projectsAndAreas;
            m_Priorities = priorities;

            newMapping = null;

            DisplayProductsAndApplications();
            DisplayPriorities();
            DisplayProjectsAndAreas();

            DialogResult result = ShowDialog();
            if (result == DialogResult.OK)
            {
                newMapping = new Mapping();
                UpdateData(newMapping);
            }

            return result;
        }

		public OneToManyPersister(Mapping.Collection collection, ICacheConcurrencyStrategy cache, Configuration cfg, ISessionFactoryImplementor factory)
			: base(collection, cache, cfg, factory)
		{
			_cascadeDeleteEnabled = collection.Key.IsCascadeDeleteEnabled && factory.Dialect.SupportsCascadeDelete;
			_keyIsNullable = collection.Key.IsNullable;
			_keyIsUpdateable = collection.Key.IsUpdateable;
		}

        public DialogResult EditMapping(Dictionary<string, List<String>> productsAndApplications, 
            Dictionary<string, List<String>> projectsAndAreas,
            Dictionary<int, string> priorities,
            Mapping existingMapping)
        {
            Text = EditMappingTitle;

            m_ProductsAndApplications = productsAndApplications;
            m_ProjectsAndAreas = projectsAndAreas;
            m_Priorities = priorities;

            DisplayProductsAndApplications();
            DisplayPriorities();
            DisplayProjectsAndAreas();

            //display the current mapping values
            ProductSelection.Text = existingMapping.Product;
            ApplicationSelection.Text = existingMapping.Application;
            txtVersions.Text = existingMapping.Versions;

            ProjectSelection.SelectedItem = existingMapping.Project;
            AreaSelection.SelectedItem = existingMapping.Area;
            PrioritySelection.SelectedValue = existingMapping.Priority;

            DialogResult result = ShowDialog();
            if (result == DialogResult.OK)
            {
                UpdateData(existingMapping);
            }

            return result;
        }

		public BasicCollectionPersister(
			Mapping.Collection collection,
			ICacheConcurrencyStrategy cache,
			ISessionFactoryImplementor factory)
			: base(collection, cache, factory)
		{
		}

        public void RegisterMapping(ICompilerInputContract contract, ICompilerInputContractMapping dataRowContractMapping)
        {
            var properties = contract.Properties.Select(p => new CompilerInputContractProperty(p)).ToList();
            var fieldMappings = dataRowContractMapping.Mapping.ToList();

            var ixPropertyNames = new HashSet<string>(this.m_columnInfos.Select(c => c.ColumnName), StringComparer.OrdinalIgnoreCase);

            //if (fieldMappings.Count > properties.Count)
            //{
            //    m_compilerOutputBuilder.AddError(
            //        m_compilerNotificationMessageBuilder.TooFewTableTypeInterfaceMappingItems(m_fullName, contract.InterfaceName, properties.Count, fieldMappings.Count));
            //}

            var unexpectedColumnMappingNames = fieldMappings.Where(m => !(this.m_ixColumnNames.Contains(m.DataFieldName)));

            var mapping = new Mapping<DataColumnInfo, CompilerInputContractProperty>(
                dataRowContractMapping
                .Mapping
                .ToDictionary(m => m.DataFieldName, m => m.ContractPropertyName, StringComparer.Ordinal));

            var pairs = mapping.Map(this.m_columnInfos, properties);

            foreach (var pair in pairs)
            {
                this.m_interfaceMappings.Add(
                    new CompilerOutputInterfacePropertyMapping
                    {
                        InterfaceName = dataRowContractMapping.InterfaceName,
                        ColumnName = pair.Source.ColumnName,
                        PropertyName = pair.Target.PropertyName,
                        PropertyType = pair.Target.PropertyType
                    });
            }
        }

		/// <summary>
		/// Generates a VersionProperty representation for an entity mapping given its
		/// version mapping Property.
		/// </summary>
		/// <param name="property">The version mapping Property.</param>
		/// <param name="lazyAvailable">Is property lazy loading currently available.</param>
		/// <returns>The appropriate VersionProperty definition.</returns>
		public static VersionProperty BuildVersionProperty(Mapping.Property property, bool lazyAvailable)
		{
			String mappedUnsavedValue = ((IKeyValue) property.Value).NullValue;

			VersionValue unsavedValue = UnsavedValueFactory.GetUnsavedVersionValue(
				mappedUnsavedValue,
				GetGetter(property),
				(IVersionType) property.Type,
				GetConstructor(property.PersistentClass)
				);

			bool lazy = lazyAvailable && property.IsLazy;

			return new VersionProperty(
				property.Name,
				property.NodeName,
				property.Value.Type,
				lazy,
				property.IsInsertable,
				property.IsUpdateable,
				property.Generation == PropertyGeneration.Insert || property.Generation == PropertyGeneration.Always,
				property.Generation == PropertyGeneration.Always,
				property.IsOptional,
				property.IsUpdateable && !lazy,
				property.IsOptimisticLocked,
				property.CascadeStyle,
				unsavedValue
				);
		}

        public MappingEntry(Mapping mapping, ExcelWorksheet sourceWorksheet, int index)
        {
            var contentMapping = mapping as ContentMapping;
            var movableMapping = mapping as MovableMapping;
            var cellMapping = mapping as CellMapping;
            var formulaMapping = mapping as FormulaMapping;

            if (contentMapping != null)
                Value = contentMapping.GetValue();
            else if (movableMapping != null)
                Value = movableMapping.GetValue(index, sourceWorksheet);
            else if (cellMapping != null)
                Value = cellMapping.GetValue(sourceWorksheet);
            else if (formulaMapping != null)
            {
                IsFormula = true;
                Value = formulaMapping.GetValue();
            }
            else
                throw new InvalidOperationException("Nieznany rodzaj próbki.");

            Mapping = mapping;

            if (mapping.IsDateColumnMapping() && Value != null) 
            	Value = ExcelHelper.ToDate(Value, Mapping.Sample.Card.DateFormats.ToArray());
        }

 public void Setup()
 {
     mainPanel = MockRepository.GenerateStub<IMainPanel>();
     form = MockRepository.GenerateMock<IMappingForm>();
     mapping = MockRepository.GenerateStub<Mapping>();
     mapping.MappingSet = new MappingSetImpl();
     //presenter = new MappingPresenter(mainPanel, form);
 }

 public ManyToManyAttribute( Type childType, Mapping.Loading loading, Cascade cascade )
     : base()
 {
     this.ChildReturnType = childType;
     this.Linked = true;
     this.Loading = loading;
     this.Cascade = cascade;
 }

		public string FindMappingFile(string filename, Mapping mapType)
		{
			var sb = new StringBuilder(Material.TextureNameBufferLength);

			this.FindMappingFile(sb, filename, mapType);

			return sb.ToString();
		}