MARKUS

        //DataSearch 상단 그리드 Search 

        public ConvertItem(string ConvertId ,string ProjectNo, int Status, string documentID, string documentName, string documentNo, string document_URL, string revision, int currentPageNo, int totalPage, string exception, string groupNo)

        {//세미

            ConvertID = ConvertId;

            ProjectNumber = ProjectNo;

            ConvertState = (StatusCodeType)Status;

            DocumentID = documentID;

            DocumnetName = documentName;

            DocumnetNo = documentNo;

            DocumnetURL = document_URL;

            Revision = revision;

            CurrentPageNo = currentPageNo;

            TotalPage = totalPage;

            Exception = exception;

            GroupNo = groupNo;

        }

        string _documentURL;

        public string DocumnetURL

        {

            get

            {

                return _documentURL;

            }

            set

            {

                if (_documentURL != value)

                {

                    _documentURL = value;

                    OnPropertyChanged("_documentURL");

                }

            }

        }

        [DataMember]

        public IEnumerable<Interface.ConvertItem> GetConvertProjects(int status,string ProjectNumberFilter, string UniqueKeyFilter, string Docuemnt_NameFilter, string Service_IDFilter, string Docuemnt_NOFilter, int? ReconverterFilter

            , string RevisionFilter)

        {

            List<Interface.ConvertItem> convertItems = new List<Interface.ConvertItem>();

            var query = from items in entities.CONVERTER_DOC

                        join documents in entities.DOCUMENT_ITEM on items.DOCUMENT_ID equals documents.DOCUMENT_ID into GroupItems

                        from subpet in GroupItems.DefaultIfEmpty()

                        where items.STATUS == status &&

                        //

                        (

                         items.PROJECT_NO.Contains(ProjectNumberFilter)

                         || subpet.DOCUMENT_NAME.Contains(Docuemnt_NameFilter)

                         || items.SERVICE_ID.Contains(Service_IDFilter)

                         || subpet.ID.Contains(UniqueKeyFilter)

                         || subpet.DOCUMENT_NO.Contains(Docuemnt_NOFilter)

                         || items.RECONVERTER == ReconverterFilter

                         || subpet.REVISION.Contains(RevisionFilter)

                         )

                       //

                        orderby items.CREATE_DATETIME descending

                        select new

                        {

                            ID = items.ID,

                            DOCUMENT_URL = items.DOCUMENT_URL,

                            RECONVERTER = items.RECONVERTER,

                            SERVICE_ID = items.SERVICE_ID,

                            STATUS = items.STATUS,

                            CREATE_DATETIME = items.CREATE_DATETIME,

                            START_DATETIME = items.START_DATETIME,

                            END_DATETIME = items.END_DATETIME,

                            TOTAL_PAGE = items.TOTAL_PAGE,

                            CURRENT_PAGE = items.CURRENT_PAGE,

                            EXCEPTION = items.EXCEPTION,

                            PROJECT_NO = items.PROJECT_NO,

                            DOCUMENT_ID = items.DOCUMENT_ID,

                            REVISION = subpet.REVISION,

                            DOCUMENT_NO = subpet.DOCUMENT_NO,

                            DOCUMENT_NAME = subpet.DOCUMENT_NAME,

                            GROUP_NO = subpet.GROUP_NO,

                        };

            if (query.Count() > 0)//세미

            {

                foreach (var item in query)

                {

                    Interface.ConvertItem convertitem = new Interface.ConvertItem(item.DOCUMENT_ID, item.PROJECT_NO, item.ID, item.DOCUMENT_URL)

                    {

                        ReConverter = item.RECONVERTER,

                        ServiceID = item.SERVICE_ID,

                        ConvertState = (StatusCodeType)item.STATUS,

                        CreateTime = item.CREATE_DATETIME,

                        StartTime = (DateTime)item.START_DATETIME,

                        EndTime = (DateTime)item.END_DATETIME,

                        TotalPage = item.TOTAL_PAGE,

                        CurrentPageNo = item.CURRENT_PAGE,

                        Exception = item.EXCEPTION,

                        ConvertPath = GetConvertPath(item.PROJECT_NO, item.DOCUMENT_ID),

                        Revision = item.REVISION,

                        DocumnetNo = item.DOCUMENT_NO,

                        DocumnetName = item.DOCUMENT_NAME,

                        GroupNo = item.GROUP_NO,

                        DocumentID = item.DOCUMENT_ID,

                        MarkusLink = "kcom://" + Markus.Service.DataBase.Extensions.MarkusAPI.CreateMarkusParam(item.PROJECT_NO, item.DOCUMENT_ID, "doftech")

                    };

                    convertItems.Add(convertitem);

                }

            }

            return convertItems;

        }

                        orderby items.CREATE_DATETIME descending

  <connectionStrings>

    <add name="markusEntities" connectionString="metadata=res://*/MarkusModel.csdl|res://*/MarkusModel.ssdl|res://*/MarkusModel.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=192.168.0.67;initial catalog=markus;persist security info=True;user id=doftech;password=dof1073#;MultipleActiveResultSets=True;App=EntityFramework&quot;" providerName="System.Data.EntityClient" />

  </connectionStrings>

<UserControl x:Name="userControl" x:Class="Markus.Service.StationController.Controls.DatabaseFilter"

      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

      xmlns:telerik="http://schemas.telerik.com/2008/xaml/presentation"

      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 

      xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 

      xmlns:local="clr-namespace:Markus.Service.StationController.Views"

      xmlns:VM="clr-namespace:Markus.Service.StationController.ViewModel"

      mc:Ignorable="d"  >

    <Grid HorizontalAlignment="Left">

        <Grid.Style>

            <Style>

                <Setter Property="TextBlock.Margin" Value="20,0,0,0"/>

            </Style>

        </Grid.Style>

        <!--<Grid.RowDefinitions>

            <RowDefinition />

            <RowDefinition/>

            <RowDefinition />

            <RowDefinition/>

            <RowDefinition/>

        </Grid.RowDefinitions>

        <Grid.ColumnDefinitions>

            <ColumnDefinition />

            <ColumnDefinition />

            <ColumnDefinition />

            <ColumnDefinition />

            <ColumnDefinition />

            <ColumnDefinition />

        </Grid.ColumnDefinitions>-->

        <Grid.RowDefinitions>

            <RowDefinition />

            <RowDefinition />

            <RowDefinition />

        </Grid.RowDefinitions>

        <Grid.ColumnDefinitions>

            <ColumnDefinition Width="*" />

            <ColumnDefinition Width="Auto"/>

            <ColumnDefinition Width="*"/>

            <ColumnDefinition Width="Auto"/>

            <ColumnDefinition Width="*"/>

            <ColumnDefinition Width="Auto"/>

            <ColumnDefinition Width="*"/>

            <ColumnDefinition Width="Auto"/>

        </Grid.ColumnDefinitions>

        <TextBlock Text="ProjectNumber  " Grid.Row="0" Grid.Column="0" VerticalAlignment="Center"/>

        <telerik:RadMaskedTextInput IsClearButtonVisible="True" Grid.Row="0" Grid.Column="1"  Width="300"

         EmptyContent="ProjectNumber" InputBehavior="Replace" HorizontalContentAlignment="Stretch"

         TextMode="PlainText" Value="{Binding ProjectNo,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay, ElementName=userControl}"

         VerticalAlignment="Center" />

        <TextBlock Text="UniqueKey  " Grid.Row="0" Grid.Column="2" Margin="20,0,0,0" VerticalAlignment="Center"/>

        <telerik:RadMaskedTextInput IsClearButtonVisible="True"  Width="300"

         EmptyContent="UniqueKey" Value="{Binding UniqueKeyFilter, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"

         TextMode="PlainText" Grid.Row="0" Grid.Column="3"

         HorizontalAlignment="Center"

         VerticalAlignment="Center"/>

        <!--<TextBlock Text="ConvertState : " Grid.Row="1" Grid.Column="0"/>-->

        <!--<telerik:RadMaskedTextInput IsClearButtonVisible="True"

         EmptyContent="ConvertState" Value="{Binding ConvertStateFilter, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"

         TextMode="PlainText"  Grid.Row="1" Grid.Column="1"

         HorizontalAlignment="Center"

         VerticalAlignment="Center"/>-->

        <TextBlock Text="Docuemnt Name  " Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" Margin="0,10,0,10"/>

        <telerik:RadMaskedTextInput IsClearButtonVisible="True"  Width="300"

         EmptyContent="Docuemnt Name" Value="{Binding Docuemnt_NameFilter , UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"

         TextMode="PlainText" Grid.Row="1" Grid.Column="1"

         HorizontalContentAlignment="Stretch"

         VerticalAlignment="Center"/>

        <TextBlock Text="Docuemnt NO  " Grid.Row="1" Grid.Column="2" Margin="20,0,0,0"  VerticalAlignment="Center"/>

        <telerik:RadMaskedTextInput IsClearButtonVisible="True"  Width="300"

         EmptyContent="Docuemnt NO" Value="{Binding Docuemnt_NOFilter , UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"

         TextMode="PlainText" Grid.Row="1" Grid.Column="3"

         HorizontalAlignment="Center"

         VerticalAlignment="Center"/>

        <TextBlock Text="Service ID  " Grid.Row="0" Grid.Column="4"  Margin="20,0,10,0" VerticalAlignment="Center"/>

        <telerik:RadMaskedTextInput IsClearButtonVisible="True"  Width="300"

         EmptyContent="Service ID" Value="{Binding Service_IDFilter, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"

         TextMode="PlainText" Grid.Row="0" Grid.Column="5"

         HorizontalAlignment="Center"

         VerticalAlignment="Center"/>

        <TextBlock Text="Reconverter " Grid.Row="1" Grid.Column="4"  Margin="20,0,0,0" VerticalAlignment="Center"/>

        <telerik:RadMaskedTextInput IsClearButtonVisible="True"  Width="300"

         EmptyContent="Reconverter"  Value="{Binding ReconverterFilter, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"

         TextMode="PlainText" Grid.Row="1" Grid.Column="5"

         HorizontalAlignment="Center"

         VerticalAlignment="Center"/>

        <TextBlock Text="Revision  " Grid.Row="0" Grid.Column="6" VerticalAlignment="Center"  Margin="20,0,10,0"/>

        <telerik:RadMaskedTextInput IsClearButtonVisible="True"  Width="300"

         EmptyContent="Revision" Value="{Binding RevisionFilter, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"

         TextMode="PlainText" Grid.Row="0" Grid.Column="7"

         HorizontalContentAlignment="Stretch"

         VerticalAlignment="Center"/>

        <StackPanel Grid.Row="2" Grid.ColumnSpan="8">

            <StackPanel Orientation="Horizontal">

                <TextBlock Text="CreateTime  " VerticalAlignment="Center"/>

                <telerik:RadDateTimePicker x:Name="datePicker1" Width="800"

                                   InputMode="DateTimePicker"  

                                   VerticalAlignment="Center"

                                   HorizontalAlignment="Center"

                                   SelectedValue="{Binding SelectedCreateTimeBegin ,Mode=TwoWay,  UpdateSourceTrigger=PropertyChanged }" >

                </telerik:RadDateTimePicker>

                <!--<DatePicker Text="{Binding OpenStartTime, StringFormat='yy.mm.dd HH:mm:ss' ,RelativeSource={RelativeSource AncestorType={x:Type DatePicker}}}" SelectedDate="{Binding SelectedOpenTime}" Width="124" SelectedDateFormat="Long" Margin="0,-1,0,1"/>-->

                <TextBlock Text="  ~  "/>

                <telerik:RadDateTimePicker x:Name="datePicker2"

                                   InputMode="DateTimePicker"  HorizontalAlignment="Stretch"

                                   VerticalAlignment="Center"

                                   Width="800"

                                   SelectedValue="{Binding SelectedCreateTimeEnd ,Mode=TwoWay,  UpdateSourceTrigger=PropertyChanged}"

                                   Margin="0,1">

                </telerik:RadDateTimePicker>

                <Button Content="Clear" Margin="5"  Width="50" Height="20" HorizontalAlignment="Left" Command="{Binding RemoveCreateTimeFilterCommand, Mode=OneWay}"/>

                <!--<telerik:RadToggleButton Content=" 검색" Command="{Binding DataFilterCommand, Mode=OneWay}" Width="100" Grid.Row="3"/>-->

                <!--<DatePicker Text="{Binding OpenStartTime, StringFormat='yy.mm.dd HH:mm:ss' ,RelativeSource={RelativeSource AncestorType={x:Type DatePicker}}}" SelectedDate="{Binding SelectedOpenTime}" Width="124" SelectedDateFormat="Long" Margin="0,-1,0,1"/>-->

                <!--<telerik:RadMaskedTextInput IsClearButtonVisible="True"

         EmptyContent="placeholder text"

         TextMode="PlainText" 

         HorizontalAlignment="Center"

         VerticalAlignment="Center"/>-->

            </StackPanel>

        </StackPanel>

    </Grid>

</UserControl>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

namespace Markus.Service.StationController.Controls

{

    /// <summary>

    /// DatabaseFilter.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class DatabaseFilter : UserControl

    {

        public DatabaseFilter()

        {

            InitializeComponent();

        }

        public static readonly DependencyProperty ProjectNoProperty = DependencyProperty.Register("ProjectNo", typeof(string), typeof(DatabaseFilter), null);

        public static readonly DependencyProperty UniqueKeyProperty = DependencyProperty.Register("UniqueKey", typeof(string), typeof(DatabaseFilter), null);

        public static readonly DependencyProperty Docuemnt_NOProperty = DependencyProperty.Register("Docuemnt_NO", typeof(string), typeof(DatabaseFilter), null);

        public static readonly DependencyProperty Docuemnt_NameProperty = DependencyProperty.Register("Docuemnt_Name", typeof(string), typeof(DatabaseFilter), null);

        public static readonly DependencyProperty ReconverterProperty = DependencyProperty.Register("Reconverter", typeof(string), typeof(DatabaseFilter), null);

        public static readonly DependencyProperty Service_IDProperty = DependencyProperty.Register("Service_ID", typeof(string), typeof(DatabaseFilter), null);

        public static readonly DependencyProperty RevisionProperty = DependencyProperty.Register("Revision", typeof(string), typeof(DatabaseFilter), null);

        public static readonly DependencyProperty CreateTimeBeginProperty = DependencyProperty.Register("CreateTimeBegin", typeof(string), typeof(DatabaseFilter), null);

        public static readonly DependencyProperty CreateTimeEndProperty = DependencyProperty.Register("CreateTimeEnd", typeof(string), typeof(DatabaseFilter), null);

        public string ProjectNo

        {

            get

            {

                return (string)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

        public string UniqueKey

        {

            get

            {

                return (string)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

        public string Docuemnt_NO

        {

            get

            {

                return (string)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

        public string Docuemnt_Name

        {

            get

            {

                return (string)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

        public int? Reconverter

        {

            get

            {

                return (int?)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

        public string Service_ID

        {

            get

            {

                return (string)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

        public string Revision

        {

            get

            {

                return (string)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

        public DateTime CreateTimeBegin

        {

            get

            {

                return (DateTime)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

        public DateTime CreateTimeEnd

        {

            get

            {

                return (DateTime)this.GetValue(ProjectNoProperty);

            }

            set

            {

                this.SetValue(ProjectNoProperty, value);

            }

        }

    }

}

    <Reference Include="System.Security" />

    <Compile Include="Controls\DatabaseFilter.xaml.cs">

      <DependentUpon>DatabaseFilter.xaml</DependentUpon>

    </Compile>

    <Compile Include="MarkusModel.Context.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>MarkusModel.Context.tt</DependentUpon>

    </Compile>

    <Compile Include="MarkusModel.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="MarkusModel.Designer.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>MarkusModel.edmx</DependentUpon>

    </Compile>

    <Compile Include="SELECT_CONVERT_ITEM_Result.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="SELECT_RERECONVERT_ITEM_Result.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Page Include="Controls\DatabaseFilter.xaml">

      <Generator>MSBuild:Compile</Generator>

      <SubType>Designer</SubType>

    </Page>

    <EntityDeploy Include="MarkusModel.edmx">

      <Generator>EntityModelCodeGenerator</Generator>

      <LastGenOutput>MarkusModel.Designer.cs</LastGenOutput>

    </EntityDeploy>

    <None Include="MarkusModel.edmx.diagram">

      <DependentUpon>MarkusModel.edmx</DependentUpon>

    </None>

  <ItemGroup>

    <Content Include="MarkusModel.Context.tt">

      <Generator>TextTemplatingFileGenerator</Generator>

      <LastGenOutput>MarkusModel.Context.cs</LastGenOutput>

      <DependentUpon>MarkusModel.edmx</DependentUpon>

    </Content>

    <Content Include="MarkusModel.tt">

      <Generator>TextTemplatingFileGenerator</Generator>

      <DependentUpon>MarkusModel.edmx</DependentUpon>

      <LastGenOutput>MarkusModel.cs</LastGenOutput>

    </Content>

  </ItemGroup>

  <ItemGroup>

    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />

  </ItemGroup>

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.Service.StationController

{

    using System;

    using System.Data.Entity;

    using System.Data.Entity.Infrastructure;

    using System.Data.Entity.Core.Objects;

    using System.Linq;

    public partial class markusEntities : DbContext

    {

        public markusEntities()

            : base("name=markusEntities")

        {

        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)

        {

            throw new UnintentionalCodeFirstException();

        }

        public virtual ObjectResult<SELECT_CONVERT_ITEM_Result> SELECT_CONVERT_ITEM(string p_PROJECT_NO, string p_DOCUMENT_ID, Nullable<int> p_STATUS, Nullable<int> p_TAKE_COUNT, Nullable<System.DateTime> p_BEGIN_CREATE_DATETIME, Nullable<System.DateTime> p_FINISH_CREATE_DATETIME, Nullable<System.DateTime> p_BEGIN_START_DATETIE, Nullable<System.DateTime> p_FINISH_START_DATETIME, Nullable<System.DateTime> p_BEGIN_END_DATETIME, Nullable<System.DateTime> p_FINISH_END_DATETIME, string p_GROUP_NO, string p_DOCUMENT_NAME, string p_DOCUMENT_NO, string p_REVISION)

        {

            var p_PROJECT_NOParameter = p_PROJECT_NO != null ?

                new ObjectParameter("P_PROJECT_NO", p_PROJECT_NO) :

                new ObjectParameter("P_PROJECT_NO", typeof(string));

            var p_DOCUMENT_IDParameter = p_DOCUMENT_ID != null ?

                new ObjectParameter("P_DOCUMENT_ID", p_DOCUMENT_ID) :

                new ObjectParameter("P_DOCUMENT_ID", typeof(string));

            var p_STATUSParameter = p_STATUS.HasValue ?

                new ObjectParameter("P_STATUS", p_STATUS) :

                new ObjectParameter("P_STATUS", typeof(int));

            var p_TAKE_COUNTParameter = p_TAKE_COUNT.HasValue ?

                new ObjectParameter("P_TAKE_COUNT", p_TAKE_COUNT) :

                new ObjectParameter("P_TAKE_COUNT", typeof(int));

            var p_BEGIN_CREATE_DATETIMEParameter = p_BEGIN_CREATE_DATETIME.HasValue ?

                new ObjectParameter("P_BEGIN_CREATE_DATETIME", p_BEGIN_CREATE_DATETIME) :

                new ObjectParameter("P_BEGIN_CREATE_DATETIME", typeof(System.DateTime));

            var p_FINISH_CREATE_DATETIMEParameter = p_FINISH_CREATE_DATETIME.HasValue ?

                new ObjectParameter("P_FINISH_CREATE_DATETIME", p_FINISH_CREATE_DATETIME) :

                new ObjectParameter("P_FINISH_CREATE_DATETIME", typeof(System.DateTime));

            var p_BEGIN_START_DATETIEParameter = p_BEGIN_START_DATETIE.HasValue ?

                new ObjectParameter("P_BEGIN_START_DATETIE", p_BEGIN_START_DATETIE) :

                new ObjectParameter("P_BEGIN_START_DATETIE", typeof(System.DateTime));

            var p_FINISH_START_DATETIMEParameter = p_FINISH_START_DATETIME.HasValue ?

                new ObjectParameter("P_FINISH_START_DATETIME", p_FINISH_START_DATETIME) :

                new ObjectParameter("P_FINISH_START_DATETIME", typeof(System.DateTime));

            var p_BEGIN_END_DATETIMEParameter = p_BEGIN_END_DATETIME.HasValue ?

                new ObjectParameter("P_BEGIN_END_DATETIME", p_BEGIN_END_DATETIME) :

                new ObjectParameter("P_BEGIN_END_DATETIME", typeof(System.DateTime));

            var p_FINISH_END_DATETIMEParameter = p_FINISH_END_DATETIME.HasValue ?

                new ObjectParameter("P_FINISH_END_DATETIME", p_FINISH_END_DATETIME) :

                new ObjectParameter("P_FINISH_END_DATETIME", typeof(System.DateTime));

            var p_GROUP_NOParameter = p_GROUP_NO != null ?

                new ObjectParameter("P_GROUP_NO", p_GROUP_NO) :

                new ObjectParameter("P_GROUP_NO", typeof(string));

            var p_DOCUMENT_NAMEParameter = p_DOCUMENT_NAME != null ?

                new ObjectParameter("P_DOCUMENT_NAME", p_DOCUMENT_NAME) :

                new ObjectParameter("P_DOCUMENT_NAME", typeof(string));

            var p_DOCUMENT_NOParameter = p_DOCUMENT_NO != null ?

                new ObjectParameter("P_DOCUMENT_NO", p_DOCUMENT_NO) :

                new ObjectParameter("P_DOCUMENT_NO", typeof(string));

            var p_REVISIONParameter = p_REVISION != null ?

                new ObjectParameter("P_REVISION", p_REVISION) :

                new ObjectParameter("P_REVISION", typeof(string));

            return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction<SELECT_CONVERT_ITEM_Result>("markusEntities.SELECT_CONVERT_ITEM", p_PROJECT_NOParameter, p_DOCUMENT_IDParameter, p_STATUSParameter, p_TAKE_COUNTParameter, p_BEGIN_CREATE_DATETIMEParameter, p_FINISH_CREATE_DATETIMEParameter, p_BEGIN_START_DATETIEParameter, p_FINISH_START_DATETIMEParameter, p_BEGIN_END_DATETIMEParameter, p_FINISH_END_DATETIMEParameter, p_GROUP_NOParameter, p_DOCUMENT_NAMEParameter, p_DOCUMENT_NOParameter, p_REVISIONParameter);

        }

        public virtual ObjectResult<SELECT_RERECONVERT_ITEM_Result> SELECT_RERECONVERT_ITEM(string p_ID, Nullable<int> p_RECONVERTER, Nullable<int> p_STATUS)

        {

            var p_IDParameter = p_ID != null ?

                new ObjectParameter("P_ID", p_ID) :

                new ObjectParameter("P_ID", typeof(string));

            var p_RECONVERTERParameter = p_RECONVERTER.HasValue ?

                new ObjectParameter("P_RECONVERTER", p_RECONVERTER) :

                new ObjectParameter("P_RECONVERTER", typeof(int));

            var p_STATUSParameter = p_STATUS.HasValue ?

                new ObjectParameter("P_STATUS", p_STATUS) :

                new ObjectParameter("P_STATUS", typeof(int));

            return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction<SELECT_RERECONVERT_ITEM_Result>("markusEntities.SELECT_RERECONVERT_ITEM", p_IDParameter, p_RECONVERTERParameter, p_STATUSParameter);

        }

    }

}

<#@ template language="C#" debug="false" hostspecific="true"#>

<#@ include file="EF6.Utility.CS.ttinclude"#><#@

 output extension=".cs"#><#

const string inputFile = @"MarkusModel.edmx";

var textTransform = DynamicTextTransformation.Create(this);

var code = new CodeGenerationTools(this);

var ef = new MetadataTools(this);

var typeMapper = new TypeMapper(code, ef, textTransform.Errors);

var loader = new EdmMetadataLoader(textTransform.Host, textTransform.Errors);

var itemCollection = loader.CreateEdmItemCollection(inputFile);

var modelNamespace = loader.GetModelNamespace(inputFile);

var codeStringGenerator = new CodeStringGenerator(code, typeMapper, ef);

var container = itemCollection.OfType<EntityContainer>().FirstOrDefault();

if (container == null)

{

    return string.Empty;

}

#>

//------------------------------------------------------------------------------

// <auto-generated>

// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine1")#>

//

// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine2")#>

// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine3")#>

// </auto-generated>

//------------------------------------------------------------------------------

<#

var codeNamespace = code.VsNamespaceSuggestion();

if (!String.IsNullOrEmpty(codeNamespace))

{

#>

namespace <#=code.EscapeNamespace(codeNamespace)#>

{

<#

    PushIndent("    ");

}

#>

using System;

using System.Data.Entity;

using System.Data.Entity.Infrastructure;

<#

if (container.FunctionImports.Any())

{

#>

using System.Data.Entity.Core.Objects;

using System.Linq;

<#

}

#>

<#=Accessibility.ForType(container)#> partial class <#=code.Escape(container)#> : DbContext

{

    public <#=code.Escape(container)#>()

        : base("name=<#=container.Name#>")

    {

<#

if (!loader.IsLazyLoadingEnabled(container))

{

#>

        this.Configuration.LazyLoadingEnabled = false;

<#

}

foreach (var entitySet in container.BaseEntitySets.OfType<EntitySet>())

{

    // Note: the DbSet members are defined below such that the getter and

    // setter always have the same accessibility as the DbSet definition

    if (Accessibility.ForReadOnlyProperty(entitySet) != "public")

    {

#>

        <#=codeStringGenerator.DbSetInitializer(entitySet)#>

<#

    }

}

#>

    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)

    {

        throw new UnintentionalCodeFirstException();

    }

<#

    foreach (var entitySet in container.BaseEntitySets.OfType<EntitySet>())

    {

#>

    <#=codeStringGenerator.DbSet(entitySet)#>

<#

    }

    foreach (var edmFunction in container.FunctionImports)

    {

        WriteFunctionImport(typeMapper, codeStringGenerator, edmFunction, modelNamespace, includeMergeOption: false);

    }

#>

}

<#

if (!String.IsNullOrEmpty(codeNamespace))

{

    PopIndent();

#>

}

<#

}

#>

<#+

private void WriteFunctionImport(TypeMapper typeMapper, CodeStringGenerator codeStringGenerator, EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)

{

    if (typeMapper.IsComposable(edmFunction))

    {

#>

    [DbFunction("<#=edmFunction.NamespaceName#>", "<#=edmFunction.Name#>")]

    <#=codeStringGenerator.ComposableFunctionMethod(edmFunction, modelNamespace)#>

    {

<#+

        codeStringGenerator.WriteFunctionParameters(edmFunction, WriteFunctionParameter);

#>

        <#=codeStringGenerator.ComposableCreateQuery(edmFunction, modelNamespace)#>

    }

<#+

    }

    else

    {

#>

    <#=codeStringGenerator.FunctionMethod(edmFunction, modelNamespace, includeMergeOption)#>

    {

<#+

        codeStringGenerator.WriteFunctionParameters(edmFunction, WriteFunctionParameter);

#>

        <#=codeStringGenerator.ExecuteFunction(edmFunction, modelNamespace, includeMergeOption)#>

    }

<#+

        if (typeMapper.GenerateMergeOptionFunction(edmFunction, includeMergeOption))

        {

            WriteFunctionImport(typeMapper, codeStringGenerator, edmFunction, modelNamespace, includeMergeOption: true);

        }

    }

}

public void WriteFunctionParameter(string name, string isNotNull, string notNullInit, string nullInit)

{

#>

        var <#=name#> = <#=isNotNull#> ?

            <#=notNullInit#> :

            <#=nullInit#>;

<#+

}

public const string TemplateId = "CSharp_DbContext_Context_EF6";

public class CodeStringGenerator

{

    private readonly CodeGenerationTools _code;

    private readonly TypeMapper _typeMapper;

    private readonly MetadataTools _ef;

    public CodeStringGenerator(CodeGenerationTools code, TypeMapper typeMapper, MetadataTools ef)

    {

        ArgumentNotNull(code, "code");

        ArgumentNotNull(typeMapper, "typeMapper");

        ArgumentNotNull(ef, "ef");

        _code = code;

        _typeMapper = typeMapper;

        _ef = ef;

    }

    public string Property(EdmProperty edmProperty)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} {1} {2} {{ {3}get; {4}set; }}",

            Accessibility.ForProperty(edmProperty),

            _typeMapper.GetTypeName(edmProperty.TypeUsage),

            _code.Escape(edmProperty),

            _code.SpaceAfter(Accessibility.ForGetter(edmProperty)),

            _code.SpaceAfter(Accessibility.ForSetter(edmProperty)));

    }

    public string NavigationProperty(NavigationProperty navProp)

    {

        var endType = _typeMapper.GetTypeName(navProp.ToEndMember.GetEntityType());

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} {1} {2} {{ {3}get; {4}set; }}",

            AccessibilityAndVirtual(Accessibility.ForNavigationProperty(navProp)),

            navProp.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? ("ICollection<" + endType + ">") : endType,

            _code.Escape(navProp),

            _code.SpaceAfter(Accessibility.ForGetter(navProp)),

            _code.SpaceAfter(Accessibility.ForSetter(navProp)));

    }

    public string AccessibilityAndVirtual(string accessibility)

    {

        return accessibility + (accessibility != "private" ? " virtual" : "");

    }

    public string EntityClassOpening(EntityType entity)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} {1}partial class {2}{3}",

            Accessibility.ForType(entity),

            _code.SpaceAfter(_code.AbstractOption(entity)),

            _code.Escape(entity),

            _code.StringBefore(" : ", _typeMapper.GetTypeName(entity.BaseType)));

    }

    public string EnumOpening(SimpleType enumType)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} enum {1} : {2}",

            Accessibility.ForType(enumType),

            _code.Escape(enumType),

            _code.Escape(_typeMapper.UnderlyingClrType(enumType)));

        }

    public void WriteFunctionParameters(EdmFunction edmFunction, Action<string, string, string, string> writeParameter)

    {

        var parameters = FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);

        foreach (var parameter in parameters.Where(p => p.NeedsLocalVariable))

        {

            var isNotNull = parameter.IsNullableOfT ? parameter.FunctionParameterName + ".HasValue" : parameter.FunctionParameterName + " != null";

            var notNullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", " + parameter.FunctionParameterName + ")";

            var nullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", typeof(" + TypeMapper.FixNamespaces(parameter.RawClrTypeName) + "))";

            writeParameter(parameter.LocalVariableName, isNotNull, notNullInit, nullInit);

        }

    }

    public string ComposableFunctionMethod(EdmFunction edmFunction, string modelNamespace)

    {

        var parameters = _typeMapper.GetParameters(edmFunction);

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} IQueryable<{1}> {2}({3})",

            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),

            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),

            _code.Escape(edmFunction),

            string.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray()));

    }

    public string ComposableCreateQuery(EdmFunction edmFunction, string modelNamespace)

    {

        var parameters = _typeMapper.GetParameters(edmFunction);

        return string.Format(

            CultureInfo.InvariantCulture,

            "return ((IObjectContextAdapter)this).ObjectContext.CreateQuery<{0}>(\"[{1}].[{2}]({3})\"{4});",

            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),

            edmFunction.NamespaceName,

            edmFunction.Name,

            string.Join(", ", parameters.Select(p => "@" + p.EsqlParameterName).ToArray()),

            _code.StringBefore(", ", string.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray())));

    }

    public string FunctionMethod(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)

    {

        var parameters = _typeMapper.GetParameters(edmFunction);

        var returnType = _typeMapper.GetReturnType(edmFunction);

        var paramList = String.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray());

        if (includeMergeOption)

        {

            paramList = _code.StringAfter(paramList, ", ") + "MergeOption mergeOption";

        }

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} {1} {2}({3})",

            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),

            returnType == null ? "int" : "ObjectResult<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",

            _code.Escape(edmFunction),

            paramList);

    }

    public string ExecuteFunction(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)

    {

        var parameters = _typeMapper.GetParameters(edmFunction);

        var returnType = _typeMapper.GetReturnType(edmFunction);

        var callParams = _code.StringBefore(", ", String.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray()));

        if (includeMergeOption)

        {

            callParams = ", mergeOption" + callParams;

        }

        return string.Format(

            CultureInfo.InvariantCulture,

            "return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction{0}(\"{1}\"{2});",

            returnType == null ? "" : "<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",

            edmFunction.FullName,

            callParams);

    }

    public string DbSet(EntitySet entitySet)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} virtual DbSet<{1}> {2} {{ get; set; }}",

            Accessibility.ForReadOnlyProperty(entitySet),

            _typeMapper.GetTypeName(entitySet.ElementType),

            _code.Escape(entitySet));

    }

    public string DbSetInitializer(EntitySet entitySet)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} = Set<{1}>();",

            _code.Escape(entitySet),

            _typeMapper.GetTypeName(entitySet.ElementType));

    }

    public string UsingDirectives(bool inHeader, bool includeCollections = true)

    {

        return inHeader == string.IsNullOrEmpty(_code.VsNamespaceSuggestion())

            ? string.Format(

                CultureInfo.InvariantCulture,

                "{0}using System;{1}" +

                "{2}",

                inHeader ? Environment.NewLine : "",

                includeCollections ? (Environment.NewLine + "using System.Collections.Generic;") : "",

                inHeader ? "" : Environment.NewLine)

            : "";

    }

}

public class TypeMapper

{

    private const string ExternalTypeNameAttributeName = @"http://schemas.microsoft.com/ado/2006/04/codegeneration:ExternalTypeName";

    private readonly System.Collections.IList _errors;

    private readonly CodeGenerationTools _code;

    private readonly MetadataTools _ef;

    public static string FixNamespaces(string typeName)

    {

        return typeName.Replace("System.Data.Spatial.", "System.Data.Entity.Spatial.");

    }

    public TypeMapper(CodeGenerationTools code, MetadataTools ef, System.Collections.IList errors)

    {

        ArgumentNotNull(code, "code");

        ArgumentNotNull(ef, "ef");

        ArgumentNotNull(errors, "errors");

        _code = code;

        _ef = ef;

        _errors = errors;

    }

    public string GetTypeName(TypeUsage typeUsage)

    {

        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace: null);

    }

    public string GetTypeName(EdmType edmType)

    {

        return GetTypeName(edmType, isNullable: null, modelNamespace: null);

    }

    public string GetTypeName(TypeUsage typeUsage, string modelNamespace)

    {

        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace);

    }

    public string GetTypeName(EdmType edmType, string modelNamespace)

    {

        return GetTypeName(edmType, isNullable: null, modelNamespace: modelNamespace);

    }

    public string GetTypeName(EdmType edmType, bool? isNullable, string modelNamespace)

    {

        if (edmType == null)

        {

            return null;

        }

        var collectionType = edmType as CollectionType;

        if (collectionType != null)

        {

            return String.Format(CultureInfo.InvariantCulture, "ICollection<{0}>", GetTypeName(collectionType.TypeUsage, modelNamespace));

        }

        var typeName = _code.Escape(edmType.MetadataProperties

                                .Where(p => p.Name == ExternalTypeNameAttributeName)

                                .Select(p => (string)p.Value)

                                .FirstOrDefault())

            ?? (modelNamespace != null && edmType.NamespaceName != modelNamespace ?

                _code.CreateFullName(_code.EscapeNamespace(edmType.NamespaceName), _code.Escape(edmType)) :

                _code.Escape(edmType));

        if (edmType is StructuralType)

        {

            return typeName;

        }

        if (edmType is SimpleType)

        {

            var clrType = UnderlyingClrType(edmType);

            if (!IsEnumType(edmType))

            {

                typeName = _code.Escape(clrType);

            }

            typeName = FixNamespaces(typeName);

            return clrType.IsValueType && isNullable == true ?

                String.Format(CultureInfo.InvariantCulture, "Nullable<{0}>", typeName) :

                typeName;

        }

        throw new ArgumentException("edmType");

    }

    public Type UnderlyingClrType(EdmType edmType)

    {

        ArgumentNotNull(edmType, "edmType");

        var primitiveType = edmType as PrimitiveType;

        if (primitiveType != null)

        {

            return primitiveType.ClrEquivalentType;

        }

        if (IsEnumType(edmType))

        {

            return GetEnumUnderlyingType(edmType).ClrEquivalentType;

        }

        return typeof(object);

    }

    public object GetEnumMemberValue(MetadataItem enumMember)

    {

        ArgumentNotNull(enumMember, "enumMember");

        var valueProperty = enumMember.GetType().GetProperty("Value");

        return valueProperty == null ? null : valueProperty.GetValue(enumMember, null);

    }

    public string GetEnumMemberName(MetadataItem enumMember)

    {

        ArgumentNotNull(enumMember, "enumMember");

        var nameProperty = enumMember.GetType().GetProperty("Name");

        return nameProperty == null ? null : (string)nameProperty.GetValue(enumMember, null);

    }

    public System.Collections.IEnumerable GetEnumMembers(EdmType enumType)

    {

        ArgumentNotNull(enumType, "enumType");

        var membersProperty = enumType.GetType().GetProperty("Members");

        return membersProperty != null 

            ? (System.Collections.IEnumerable)membersProperty.GetValue(enumType, null)

            : Enumerable.Empty<MetadataItem>();

    }

    public bool EnumIsFlags(EdmType enumType)

    {

        ArgumentNotNull(enumType, "enumType");

        var isFlagsProperty = enumType.GetType().GetProperty("IsFlags");

        return isFlagsProperty != null && (bool)isFlagsProperty.GetValue(enumType, null);

    }

    public bool IsEnumType(GlobalItem edmType)

    {

        ArgumentNotNull(edmType, "edmType");

        return edmType.GetType().Name == "EnumType";

    }

    public PrimitiveType GetEnumUnderlyingType(EdmType enumType)

    {

        ArgumentNotNull(enumType, "enumType");

        return (PrimitiveType)enumType.GetType().GetProperty("UnderlyingType").GetValue(enumType, null);

    }

    public string CreateLiteral(object value)

    {

        if (value == null || value.GetType() != typeof(TimeSpan))

        {

            return _code.CreateLiteral(value);

        }

        return string.Format(CultureInfo.InvariantCulture, "new TimeSpan({0})", ((TimeSpan)value).Ticks);

    }

    public bool VerifyCaseInsensitiveTypeUniqueness(IEnumerable<string> types, string sourceFile)

    {

        ArgumentNotNull(types, "types");

        ArgumentNotNull(sourceFile, "sourceFile");

        var hash = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);

        if (types.Any(item => !hash.Add(item)))

        {

            _errors.Add(

                new CompilerError(sourceFile, -1, -1, "6023",

                    String.Format(CultureInfo.CurrentCulture, CodeGenerationTools.GetResourceString("Template_CaseInsensitiveTypeConflict"))));

            return false;

        }

        return true;

    }

    public IEnumerable<SimpleType> GetEnumItemsToGenerate(IEnumerable<GlobalItem> itemCollection)

    {

        return GetItemsToGenerate<SimpleType>(itemCollection)

            .Where(e => IsEnumType(e));

    }

    public IEnumerable<T> GetItemsToGenerate<T>(IEnumerable<GlobalItem> itemCollection) where T: EdmType

    {

        return itemCollection

            .OfType<T>()

            .Where(i => !i.MetadataProperties.Any(p => p.Name == ExternalTypeNameAttributeName))

            .OrderBy(i => i.Name);

    }

    public IEnumerable<string> GetAllGlobalItems(IEnumerable<GlobalItem> itemCollection)

    {

        return itemCollection

            .Where(i => i is EntityType || i is ComplexType || i is EntityContainer || IsEnumType(i))

            .Select(g => GetGlobalItemName(g));

    }

    public string GetGlobalItemName(GlobalItem item)

    {

        if (item is EdmType)

        {

            return ((EdmType)item).Name;

        }

        else

        {

            return ((EntityContainer)item).Name;

        }

    }

    public IEnumerable<EdmProperty> GetSimpleProperties(EntityType type)

    {

        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);

    }

    public IEnumerable<EdmProperty> GetSimpleProperties(ComplexType type)

    {

        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);

    }

    public IEnumerable<EdmProperty> GetComplexProperties(EntityType type)

    {

        return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);

    }

    public IEnumerable<EdmProperty> GetComplexProperties(ComplexType type)

    {

        return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);

    }

    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(EntityType type)

    {

        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);

    }

    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(ComplexType type)

    {

        return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);

    }

    public IEnumerable<NavigationProperty> GetNavigationProperties(EntityType type)

    {

        return type.NavigationProperties.Where(np => np.DeclaringType == type);

    }

    public IEnumerable<NavigationProperty> GetCollectionNavigationProperties(EntityType type)

    {

        return type.NavigationProperties.Where(np => np.DeclaringType == type && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many);

    }

    public FunctionParameter GetReturnParameter(EdmFunction edmFunction)

    {

        ArgumentNotNull(edmFunction, "edmFunction");

        var returnParamsProperty = edmFunction.GetType().GetProperty("ReturnParameters");

        return returnParamsProperty == null

            ? edmFunction.ReturnParameter

            : ((IEnumerable<FunctionParameter>)returnParamsProperty.GetValue(edmFunction, null)).FirstOrDefault();

    }

    public bool IsComposable(EdmFunction edmFunction)

    {

        ArgumentNotNull(edmFunction, "edmFunction");

        var isComposableProperty = edmFunction.GetType().GetProperty("IsComposableAttribute");

        return isComposableProperty != null && (bool)isComposableProperty.GetValue(edmFunction, null);

    }

    public IEnumerable<FunctionImportParameter> GetParameters(EdmFunction edmFunction)

    {

        return FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);

    }

    public TypeUsage GetReturnType(EdmFunction edmFunction)

    {

        var returnParam = GetReturnParameter(edmFunction);

        return returnParam == null ? null : _ef.GetElementType(returnParam.TypeUsage);

    }

    public bool GenerateMergeOptionFunction(EdmFunction edmFunction, bool includeMergeOption)

    {

        var returnType = GetReturnType(edmFunction);

        return !includeMergeOption && returnType != null && returnType.EdmType.BuiltInTypeKind == BuiltInTypeKind.EntityType;

    }

}

public static void ArgumentNotNull<T>(T arg, string name) where T : class

{

    if (arg == null)

    {

        throw new ArgumentNullException(name);

    }

}

#>

// 모델 'E:\Source\MARKUS\ConvertService\ServiceBase\Markus.Service.StationController\MarkusModel.edmx'에 대해 T4 코드 생성이 사용됩니다. 

// 레거시 코드 생성을 사용하려면 '코드 생성 전략' 디자이너 속성의 값을

// 'Legacy ObjectContext'로 변경하십시오. 이 속성은 모델이 디자이너에서 열릴 때

// 속성 창에서 사용할 수 있습니다.

// 컨텍스트 및 엔터티 클래스가 생성되지 않은 경우 빈 모델을 만들었기 때문일 수도 있지만

// 사용할 Entity Framework 버전을 선택하지 않았기 때문일 수도 있습니다. 모델에 맞는 컨텍스트 클래스 및

// 엔터티 클래스를 생성하려면 디자이너에서 모델을 열고 디자이너 화면에서 마우스 오른쪽 단추를 클릭한

// 다음 '데이터베이스에서 모델 업데이트...', '모델에서 데이터베이스 생성...' 또는 '코드 생성 항목 추가...'를

// 선택하십시오.

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

<?xml version="1.0" encoding="utf-8"?>

<edmx:Edmx Version="3.0" xmlns:edmx="http://schemas.microsoft.com/ado/2009/11/edmx">

  <!-- EF Runtime content -->

  <edmx:Runtime>

    <!-- SSDL content -->

    <edmx:StorageModels>

    <Schema Namespace="markusModel.Store" Provider="System.Data.SqlClient" ProviderManifestToken="2012" Alias="Self" xmlns:customannotation="http://schemas.microsoft.com/ado/2013/11/edm/customannotation" xmlns="http://schemas.microsoft.com/ado/2009/11/edm/ssdl">

        <Function Name="SELECT_CONVERT_ITEM" Aggregate="false" BuiltIn="false" NiladicFunction="false" IsComposable="false" ParameterTypeSemantics="AllowImplicitConversion" Schema="dbo">

          <Parameter Name="P_PROJECT_NO" Type="nvarchar" Mode="In" />

          <Parameter Name="P_DOCUMENT_ID" Type="nvarchar" Mode="In" />

          <Parameter Name="P_STATUS" Type="int" Mode="In" />

          <Parameter Name="P_TAKE_COUNT" Type="int" Mode="In" />

          <Parameter Name="P_BEGIN_CREATE_DATETIME" Type="datetime" Mode="In" />

          <Parameter Name="P_FINISH_CREATE_DATETIME" Type="datetime" Mode="In" />

          <Parameter Name="P_BEGIN_START_DATETIE" Type="datetime" Mode="In" />

          <Parameter Name="P_FINISH_START_DATETIME" Type="datetime" Mode="In" />

          <Parameter Name="P_BEGIN_END_DATETIME" Type="datetime" Mode="In" />

          <Parameter Name="P_FINISH_END_DATETIME" Type="datetime" Mode="In" />

          <Parameter Name="P_GROUP_NO" Type="nvarchar" Mode="In" />

          <Parameter Name="P_DOCUMENT_NAME" Type="nvarchar" Mode="In" />

          <Parameter Name="P_DOCUMENT_NO" Type="nvarchar" Mode="In" />

          <Parameter Name="P_REVISION" Type="nvarchar" Mode="In" />

        </Function>

        <Function Name="SELECT_RERECONVERT_ITEM" Aggregate="false" BuiltIn="false" NiladicFunction="false" IsComposable="false" ParameterTypeSemantics="AllowImplicitConversion" Schema="dbo">

          <Parameter Name="P_ID" Type="nvarchar" Mode="In" />

          <Parameter Name="P_RECONVERTER" Type="int" Mode="In" />

          <Parameter Name="P_STATUS" Type="int" Mode="In" />

        </Function>

        <EntityContainer Name="markusModelStoreContainer" />

      </Schema></edmx:StorageModels>

    <!-- CSDL content -->

    <edmx:ConceptualModels>

      <Schema Namespace="markusModel" Alias="Self" annotation:UseStrongSpatialTypes="false" xmlns:annotation="http://schemas.microsoft.com/ado/2009/02/edm/annotation" xmlns:customannotation="http://schemas.microsoft.com/ado/2013/11/edm/customannotation" xmlns="http://schemas.microsoft.com/ado/2009/11/edm">

        <EntityContainer Name="markusEntities" annotation:LazyLoadingEnabled="true" >

          <FunctionImport Name="SELECT_CONVERT_ITEM" ReturnType="Collection(markusModel.SELECT_CONVERT_ITEM_Result)">

            <Parameter Name="P_PROJECT_NO" Mode="In" Type="String" />

            <Parameter Name="P_DOCUMENT_ID" Mode="In" Type="String" />

            <Parameter Name="P_STATUS" Mode="In" Type="Int32" />

            <Parameter Name="P_TAKE_COUNT" Mode="In" Type="Int32" />

            <Parameter Name="P_BEGIN_CREATE_DATETIME" Mode="In" Type="DateTime" />

            <Parameter Name="P_FINISH_CREATE_DATETIME" Mode="In" Type="DateTime" />

            <Parameter Name="P_BEGIN_START_DATETIE" Mode="In" Type="DateTime" />

            <Parameter Name="P_FINISH_START_DATETIME" Mode="In" Type="DateTime" />

            <Parameter Name="P_BEGIN_END_DATETIME" Mode="In" Type="DateTime" />

            <Parameter Name="P_FINISH_END_DATETIME" Mode="In" Type="DateTime" />

            <Parameter Name="P_GROUP_NO" Mode="In" Type="String" />

            <Parameter Name="P_DOCUMENT_NAME" Mode="In" Type="String" />

            <Parameter Name="P_DOCUMENT_NO" Mode="In" Type="String" />

            <Parameter Name="P_REVISION" Mode="In" Type="String" />

          </FunctionImport>

          <FunctionImport Name="SELECT_RERECONVERT_ITEM" ReturnType="Collection(markusModel.SELECT_RERECONVERT_ITEM_Result)">

            <Parameter Name="P_ID" Mode="In" Type="String" />

            <Parameter Name="P_RECONVERTER" Mode="In" Type="Int32" />

            <Parameter Name="P_STATUS" Mode="In" Type="Int32" />

          </FunctionImport>

        </EntityContainer>

        <ComplexType Name="SELECT_CONVERT_ITEM_Result">

          <Property Type="String" Name="ID" Nullable="false" MaxLength="50" />

          <Property Type="String" Name="PROJECT_NO" Nullable="false" MaxLength="10" />

          <Property Type="String" Name="DOCUMENT_URL" Nullable="false" MaxLength="500" />

          <Property Type="String" Name="DOCUMENT_ID" Nullable="false" MaxLength="50" />

          <Property Type="DateTime" Name="CREATE_DATETIME" Nullable="false" Precision="23" />

          <Property Type="Int32" Name="STATUS" Nullable="false" />

          <Property Type="Int32" Name="TOTAL_PAGE" Nullable="false" />

          <Property Type="Int32" Name="CURRENT_PAGE" Nullable="false" />

          <Property Type="String" Name="EXCEPTION" Nullable="true" />

          <Property Type="DateTime" Name="END_DATETIME" Nullable="true" Precision="23" />

          <Property Type="DateTime" Name="START_DATETIME" Nullable="true" Precision="23" />

          <Property Type="String" Name="SERVICE_ID" Nullable="true" MaxLength="50" />

          <Property Type="Int32" Name="RECONVERTER" Nullable="true" />

          <Property Type="String" Name="REVISION" Nullable="true" MaxLength="50" />

          <Property Type="String" Name="DOCUMENT_NO" Nullable="true" MaxLength="50" />

          <Property Type="String" Name="DOCUMENT_NAME" Nullable="true" MaxLength="500" />

          <Property Type="String" Name="GROUP_NO" Nullable="true" MaxLength="50" />

          <Property Type="String" Name="RESULT_FILE" Nullable="true" MaxLength="500" />

          <Property Type="String" Name="RESULT" Nullable="true" MaxLength="50" />

        </ComplexType>

        <ComplexType Name="SELECT_RERECONVERT_ITEM_Result">

          <Property Type="String" Name="EX" Nullable="true" MaxLength="50" />

          <Property Type="Int32" Name="RETURNVALUE" Nullable="true" />

        </ComplexType>

      </Schema>

    </edmx:ConceptualModels>

    <!-- C-S mapping content -->

    <edmx:Mappings>

      <Mapping Space="C-S" xmlns="http://schemas.microsoft.com/ado/2009/11/mapping/cs">

        <EntityContainerMapping StorageEntityContainer="markusModelStoreContainer" CdmEntityContainer="markusEntities" >

          <FunctionImportMapping FunctionImportName="SELECT_CONVERT_ITEM" FunctionName="markusModel.Store.SELECT_CONVERT_ITEM">

            <ResultMapping>

              <ComplexTypeMapping TypeName="markusModel.SELECT_CONVERT_ITEM_Result">

                <ScalarProperty Name="ID" ColumnName="ID" />

                <ScalarProperty Name="PROJECT_NO" ColumnName="PROJECT_NO" />