content stringlengths 5 1.04M | avg_line_length float64 1.75 12.9k | max_line_length int64 2 244k | alphanum_fraction float64 0 0.98 | licenses list | repository_name stringlengths 7 92 | path stringlengths 3 249 | size int64 5 1.04M | lang stringclasses 2
values |
|---|---|---|---|---|---|---|---|---|
/**
* Copyright 2021 The Nakama Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections;
using UnityEngine;
namespace PiratePanic
{
/// <summary>
/// Object represending dragged card shown upon hovering it over allowed drop region.
/// </summary>
public class DropVisualizer : MonoBehaviour
{
/// <summary>
/// The speed at which this object will scale up/down upon creation/destruction.
/// This will create a smooth easing animation.
/// </summary>
[SerializeField] private float _zoomSpeed = 10;
/// <summary>
/// Maximum zoom in scale.
/// </summary>
private float _maxScale = 1;
/// <summary>
/// Mimimum zoom out scale.
/// </summary>
private float _minScale = 0;
private GameStateManager _stateManager;
private bool _isHost;
public void Init(GameStateManager stateManager, bool isHost)
{
_stateManager = stateManager;
_isHost = isHost;
}
/// <summary>
/// Invoked on every update when this object is visible.
/// Sends a raycast to determine current poiner position on the battlefield.
/// </summary>
public virtual void UpdatePosition(DropRegion dropRegion, LayerMask mask)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, mask))
{
Vector2Int nodePosition = Scene02BattleController.Instance.ScreenToNodePos(hit.point, _isHost, dropRegion);
Node node = Scene02BattleController.Instance.Nodes[nodePosition.x, nodePosition.y];
transform.position = node.transform.position;
}
}
/// <summary>
/// Makes this visualizer visible to the user over a time period.
/// </summary>
public void ShowVisualizer(CardGrabber grabber, bool isHost)
{
if (isHost)
{
transform.Rotate(Vector3.up, 180);
}
StartCoroutine(ScaleUpCoroutine(grabber, _zoomSpeed));
}
/// <summary>
/// Makes this visualizer invisible to the user over a time period.
/// </summary>
public void HideVisualizer(CardGrabber grabber)
{
StartCoroutine(ScaleDownCoroutine(grabber, _zoomSpeed, () =>
{
Destroy(gameObject);
}));
}
/// <summary>
/// Scales this visualizer up over time.
/// Scales <see cref="CardGrabber"/> held by the user down over the same time period.
/// Invokes <paramref name="onEnded"/> when finished.
/// </summary>
private IEnumerator ScaleUpCoroutine(CardGrabber grabber, float speed, Action onEnded = null)
{
float scale = _minScale;
while (scale < _maxScale)
{
scale = Mathf.Min(scale + speed * Time.deltaTime, _maxScale);
transform.localScale = Vector3.one * scale;
grabber.transform.localScale = Vector3.one * (1 - scale);
yield return null;
}
onEnded?.Invoke();
}
/// <summary>
/// Scales this visualizer down over time.
/// Scales <see cref="CardGrabber"/> held by the user up over the same time period.
/// </summary>
private IEnumerator ScaleDownCoroutine(CardGrabber grabber, float speed, Action onEnded = null)
{
float scale = _maxScale;
while (scale > _minScale)
{
scale = Mathf.Max(scale - speed * Time.deltaTime, _minScale);
transform.localScale = Vector3.one * scale;
if (grabber != null)
{
grabber.transform.localScale = Vector3.one * (1 - scale);
}
yield return null;
}
onEnded?.Invoke();
}
}
}
| 29.363636 | 111 | 0.694788 | [
"Apache-2.0"
] | heroiclabs/unity-sampleproject | PiratePanic/Assets/PiratePanic/Scripts/Menus/Battle/Hand/DropVisualizer.cs | 3,878 | C# |
using System;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using Microsoft.JSInterop;
namespace AntDesign
{
public partial class Dialog
{
private const string IdPrefix = "Ant-Design-";
[Parameter]
public DialogOptions Config { get; set; }
[Parameter]
public RenderFragment ChildContent { get; set; }
[Parameter]
public bool Visible { get; set; }
private string _maskAnimation = "";
private string _modalAnimation = "";
private string _maskHideClsName = "";
private bool _hasShow;
private bool _hasDestroy = true;
private string _wrapStyle = "";
private bool _disableBodyScroll;
private bool _doDragable = false;
/// <summary>
/// dialog root container
/// </summary>
private ElementReference _element;
private ElementReference _dialogHeader;
private ElementReference _modal;
private bool _isFirstRender = true;
#region ant-modal style
private string _modalStyle = null;
/// <summary>
/// ant-modal style
/// </summary>
/// <returns></returns>
private string GetStyle()
{
if (_modalStyle == null)
{
var style = $"{Config.GetWidth()};";
if (Config.Draggable)
{
string left = $"margin: 0; padding-bottom:0;";
style += left;
}
_modalStyle = style;
}
if (!string.IsNullOrWhiteSpace(Style))
{
return _modalStyle + Style + ";";
}
return _modalStyle;
}
/// <summary>
/// if Modal is draggable, reset the position style similar with the first show
/// </summary>
internal async Task TryResetModalStyle()
{
if (Config.Draggable)
{
await JsInvokeAsync(JSInteropConstants.ResetModalPosition, _dialogHeader);
}
}
#endregion
/// <summary>
/// append To body
/// </summary>
/// <returns></returns>
private async Task AppendToContainer()
{
await JsInvokeAsync(JSInteropConstants.AddElementTo, _element, Config.GetContainer);
}
#region mask and dialog click event
/// <summary>
/// check is dialog click
/// </summary>
private bool _dialogMouseDown = false;
private void OnDialogMouseDown()
{
_dialogMouseDown = true;
}
private async Task OnMaskMouseUp()
{
if (Config.MaskClosable && _dialogMouseDown)
{
await Task.Delay(50);
_dialogMouseDown = false;
}
}
private async Task OnMaskClick(MouseEventArgs e)
{
if (Config.MaskClosable
&& !_dialogMouseDown)
{
await CloseAsync();
}
}
#endregion
#region keyboard control
/// <summary>
/// TAB keyboard control
/// </summary>
private readonly string _sentinelStart = IdPrefix + Guid.NewGuid().ToString();
private readonly string _sentinelEnd = IdPrefix + Guid.NewGuid().ToString();
public string SentinelStart => _sentinelStart;
private async Task OnKeyDown(KeyboardEventArgs e)
{
if (Config.Keyboard && e.Key == "Escape")
{
await CloseAsync();
return;
}
if (Visible)
{
if (e.Key == "Tab")
{
var activeElement = await JsInvokeAsync<string>(JSInteropConstants.GetActiveElement, _sentinelEnd);
if (e.ShiftKey)
{
if (activeElement == _sentinelStart)
{
await JsInvokeAsync(JSInteropConstants.Focus, "#" + _sentinelEnd);
}
}
else if (activeElement == _sentinelEnd)
{
await JsInvokeAsync(JSInteropConstants.Focus, "#" + _sentinelStart);
}
}
}
}
#endregion
private async Task OnCloserClick(MouseEventArgs e)
{
await CloseAsync();
}
private async Task CloseAsync()
{
if (_hasDestroy)
{
return;
}
if (Config.OnCancel != null)
{
await Config.OnCancel.Invoke(null);
}
}
#region control show and hide class name and style
private void Show()
{
if (_hasShow)
{
return;
}
if (Visible)
{
if (Config.Draggable)
{
_wrapStyle = "display:flex;justify-content: center;";
if (Config.Centered)
{
_wrapStyle += "align-items: center;";
}
else
{
_wrapStyle += "align-items: flex-start;";
}
}
else
{
_wrapStyle = "";
}
_maskHideClsName = "";
_maskAnimation = ModalAnimation.MaskEnter;
_modalAnimation = ModalAnimation.ModalEnter;
_hasShow = true;
}
}
public async Task Hide()
{
if (!_hasShow)
{
return;
}
if (!Visible)
{
_maskAnimation = ModalAnimation.MaskLeave;
_modalAnimation = ModalAnimation.ModalLeave;
await Task.Delay(200);
_wrapStyle = "display: none;";
_maskHideClsName = "ant-modal-mask-hidden";
_hasShow = false;
StateHasChanged();
if (Config.OnClosed != null)
{
await Config.OnClosed.Invoke();
}
}
}
#endregion
private string GetMaskClsName()
{
string clsName = _maskHideClsName;
clsName += _maskAnimation;
return clsName;
}
private string GetModalClsName()
{
string clsName = Config.ClassName;
return clsName + _modalAnimation;
}
#region override
protected override async Task OnParametersSetAsync()
{
//Reduce one rendering when showing and not destroyed
if (Visible)
{
if (!_hasDestroy)
{
Show();
}
else
{
_wrapStyle = "display: none;";
_maskHideClsName = "ant-modal-mask-hidden";
}
}
else
{
await Hide();
}
await base.OnParametersSetAsync();
}
protected override async Task OnAfterRenderAsync(bool isFirst)
{
_isFirstRender = isFirst;
if (Visible)
{
if (_hasDestroy)
{
await AppendToContainer();
_hasDestroy = false;
Show();
StateHasChanged();
}
if (!_disableBodyScroll)
{
_disableBodyScroll = true;
await JsInvokeAsync(JSInteropConstants.DisableBodyScroll);
}
if (Config.Draggable && !_doDragable)
{
_doDragable = true;
await JsInvokeAsync(JSInteropConstants.EnableDraggable, _dialogHeader, _modal, Config.DragInViewport);
}
}
else
{
if (_disableBodyScroll)
{
_disableBodyScroll = false;
await Task.Delay(250);
await JsInvokeAsync(JSInteropConstants.EnableBodyScroll);
}
if (Config.Draggable && _doDragable)
{
_doDragable = false;
await JsInvokeAsync(JSInteropConstants.DisableDraggable, _dialogHeader);
}
}
await base.OnAfterRenderAsync(isFirst);
}
#endregion
}
}
| 27.145015 | 122 | 0.461547 | [
"MIT"
] | biohazard999/ant-design-blazor | components/modal/Dialog.razor.cs | 8,987 | C# |
using System.Collections.Generic;
using System.Linq;
using Utilities;
namespace EddiDataDefinitions
{
/// <summary>
/// Crime types
/// </summary>
public class Crime : ResourceBasedLocalizedEDName<Crime>
{
static Crime()
{
resourceManager = Properties.Crimes.ResourceManager;
resourceManager.IgnoreCase = false;
missingEDNameHandler = (edname) => new Crime(edname);
None = new Crime("none");
Claim = new Crime("claim");
Fine = new Crime("fine");
Bounty = new Crime("bounty");
var Assault = new Crime("assault");
var Murder = new Crime("murder");
var Piracy = new Crime("piracy");
var Interdiction = new Crime("interdiction");
var IllegalCargo = new Crime("illegalCargo");
var DisobeyPolice = new Crime("disobeyPolice");
var FireInNoFireZone = new Crime("fireInNoFireZone");
var FireInStation = new Crime("fireInStation");
var DumpingDangerous = new Crime("dumpingDangerous");
var DumpingNearStation = new Crime("dumpingNearStation");
var BlockingAirlockMinor = new Crime("dockingMinorBlockingAirlock");
var BlockingAirlockMajor = new Crime("dockingMajorBlockingAirlock");
var BlockingLandingPadMinor = new Crime("dockingMinorBlockingLandingPad");
var BlockingLandingPadMajor = new Crime("dockingMajorBlockingLandingPad");
var TrespassMinor = new Crime("dockingMinorTresspass");
var TrespassMajor = new Crime("dockingMajorTresspass");
var Collided = new Crime("collidedAtSpeedInNoFireZone");
var CollidedWithDamage = new Crime("collidedAtSpeedInNoFireZone_hulldamage");
var RecklessWeaponsDischarge = new Crime("recklessWeaponsDischarge");
var PassengerWanted = new Crime("passengerWanted");
}
// Faction report definition
public static readonly Crime None;
public static readonly Crime Claim;
public static readonly Crime Fine;
public static readonly Crime Bounty;
// dummy used to ensure that the static constructor has run
public Crime() : this("")
{}
private Crime(string edname) : base(edname, edname)
{}
}
}
| 40.87931 | 89 | 0.630536 | [
"Apache-2.0"
] | lagoth/EDDI | DataDefinitions/Crime.cs | 2,373 | C# |
using IbanNet.Registry;
using IbanNet.Registry.Patterns;
namespace IbanNet.Builders
{
public class BankAccountBuilderTests
{
[Theory]
[InlineData(typeof(BbanBuilder))]
[InlineData(typeof(IbanBuilder))]
public void Given_null_country_when_adding_it_should_throw(Type builderType)
{
IBankAccountBuilder builder = CreateBuilder(builderType);
IbanCountry country = null;
// Act
// ReSharper disable once AssignNullToNotNullAttribute
Action act = () => builder.WithCountry(country);
// Assert
act.Should()
.ThrowExactly<ArgumentNullException>()
.Which.ParamName.Should()
.Be(nameof(country));
}
[Theory]
[InlineData(typeof(BbanBuilder))]
[InlineData(typeof(IbanBuilder))]
public void Given_country_is_not_set_when_building_it_should_throw(Type builderType)
{
string exSource = builderType.Name.Substring(0, 4).ToUpperInvariant();
IBankAccountBuilder builder = CreateBuilder(builderType);
// Act
Action act = () => builder.Build();
// Assert
act.Should()
.ThrowExactly<BankAccountBuilderException>()
.WithMessage($"The {exSource} cannot be built.")
.WithInnerException<InvalidOperationException>()
.WithMessage("The country is required.");
}
[Theory]
[InlineData(typeof(BbanBuilder))]
[InlineData(typeof(IbanBuilder))]
public void Given_country_does_not_have_bban_pattern_when_building_it_should_throw(Type builderType)
{
string exSource = builderType.Name.Substring(0, 4).ToUpperInvariant();
IBankAccountBuilder builder = CreateBuilder(builderType)
.WithCountry(new IbanCountry("XX"));
// Act
Action act = () => builder.Build();
// Assert
act.Should()
.ThrowExactly<BankAccountBuilderException>()
.WithMessage($"The {exSource} cannot be built.")
.WithInnerException<InvalidOperationException>()
.WithMessage("The country 'XX' does not define a BBAN pattern.");
}
[Theory]
[InlineData(typeof(BbanBuilder), false)]
[InlineData(typeof(IbanBuilder), true)]
public void Given_country_does_not_have_iban_pattern_when_building_it_should_throw(Type builderType, bool shouldThrow)
{
string exSource = builderType.Name.Substring(0, 4).ToUpperInvariant();
IBankAccountBuilder builder = CreateBuilder(builderType)
.WithCountry(new IbanCountry("XX")
{
Bban = new BbanStructure(
new FakePattern(new[] { new PatternToken(AsciiCategory.Digit, 10) })
)
});
// Act
Action act = () => builder.Build();
// Assert
if (shouldThrow)
{
act.Should()
.ThrowExactly<BankAccountBuilderException>()
.WithMessage($"The {exSource} cannot be built.")
.WithInnerException<InvalidOperationException>()
.WithMessage("The country 'XX' does not define a IBAN pattern.");
}
else
{
act.Should().NotThrow();
}
}
[Theory]
[InlineData(typeof(BbanBuilder), "NL", "00000000000000")]
[InlineData(typeof(BbanBuilder), "GB", "000000000000000000")]
[InlineData(typeof(IbanBuilder), "NL", "NL2200000000000000")]
[InlineData(typeof(IbanBuilder), "GB", "GB18000000000000000000")]
public void Given_only_country_when_building_it_should_not_throw(Type builderType, string countryCode, string expected)
{
IBankAccountBuilder builder = CreateBuilder(builderType)
.WithCountry(countryCode, IbanRegistry.Default);
// Act
Func<string> act = () => builder.Build();
// Assert
act.Should()
.NotThrow()
.Which.Should()
.Be(expected);
}
[Theory]
[InlineData(typeof(BbanBuilder), "NL", "123", "00000000000123")]
[InlineData(typeof(BbanBuilder), "GB", "123", "000000000000000123")]
[InlineData(typeof(IbanBuilder), "NL", "789", "NL5900000000000789")]
[InlineData(typeof(IbanBuilder), "GB", "789", "GB55000000000000000789")]
public void Given_bankAccountNumber_when_building_it_should_return_value(Type builderType, string countryCode, string bankAccountNumber, string expected)
{
IBankAccountBuilder builder = CreateBuilder(builderType)
.WithCountry(countryCode, IbanRegistry.Default)
.WithBankAccountNumber(bankAccountNumber);
// Act
string actual = builder.Build();
// Assert
actual.Should().Be(expected);
}
[Theory]
[MemberData(nameof(BuilderMethodTestCases))]
public void Given_value_is_too_short_and_padding_is_disabled_when_building_it_should_throw(
Type builderType,
Action<IBankAccountBuilder, string, bool> @delegate
)
{
string exSource = builderType.Name.Substring(0, 4).ToUpperInvariant();
IBankAccountBuilder builder = CreateBuilder(builderType)
.WithCountry("GB", IbanRegistry.Default);
@delegate(builder, "1", false);
// Act
Action act = () => builder.Build();
// Assert
act.Should()
.ThrowExactly<BankAccountBuilderException>()
.WithMessage($"The {exSource} cannot be built.")
.WithInnerException<InvalidOperationException>()
.WithMessage("The value '1' does not have the correct length of *.");
}
[Theory]
[MemberData(nameof(TooShortWithPaddingTestCases))]
public void Given_value_is_too_short_and_padding_is_enabled_when_building_it_should_pad_with_zeroes(
Type builderType,
Action<IBankAccountBuilder, string, bool> @delegate,
string countryCode,
string value,
string expected
)
{
IBankAccountBuilder builder = CreateBuilder(builderType)
.WithCountry(countryCode, IbanRegistry.Default);
@delegate(builder, value, true);
// Act
Func<string> act = () => builder.Build();
// Assert
act.Should()
.NotThrow()
.Which.Should().Be(expected);
}
[Theory]
[MemberData(nameof(BuilderMethodTestCases))]
public void Given_value_is_too_long_when_building_it_should_throw(
Type builderType,
Action<IBankAccountBuilder, string, bool> @delegate
)
{
string exSource = builderType.Name.Substring(0, 4).ToUpperInvariant();
IBankAccountBuilder builder = CreateBuilder(builderType)
.WithCountry("GB", IbanRegistry.Default);
@delegate(builder, new string('0', 100), false);
// Act
Action act = () => builder.Build();
// Assert
act.Should()
.ThrowExactly<BankAccountBuilderException>()
.WithMessage($"The {exSource} cannot be built.")
.WithInnerException<InvalidOperationException>()
.WithMessage("The value '*' does not have the correct length of *.");
}
[Theory]
[InlineData(typeof(BbanBuilder))]
[InlineData(typeof(IbanBuilder))]
public void Given_country_does_not_support_branchIdentifier_when_building_it_should_throw(Type builderType)
{
string exSource = builderType.Name.Substring(0, 4).ToUpperInvariant();
IBankAccountBuilder builder = CreateBuilder(builderType)
.WithCountry("NL", IbanRegistry.Default)
.WithBranchIdentifier("123");
// Act
Action act = () => builder.Build();
// Assert
act.Should()
.ThrowExactly<BankAccountBuilderException>()
.WithMessage($"The {exSource} cannot be built.")
.WithInnerException<InvalidOperationException>()
.WithMessage("A value for 'Branch' is not supported for country code NL.");
}
private static IBankAccountBuilder CreateBuilder(Type builderType) => (IBankAccountBuilder)Activator.CreateInstance(builderType);
public static IEnumerable<object[]> BuilderMethodTestCases()
{
Type bbanBuilder = typeof(BbanBuilder);
Type ibanBuilder = typeof(IbanBuilder);
Action<IBankAccountBuilder, string, bool> bankAccount = (b, value, pad) => b.WithBankAccountNumber(value, pad);
Action<IBankAccountBuilder, string, bool> branch = (b, value, pad) => b.WithBranchIdentifier(value, pad);
Action<IBankAccountBuilder, string, bool> bank = (b, value, pad) => b.WithBankIdentifier(value, pad);
yield return new object[] { bbanBuilder, bankAccount };
yield return new object[] { bbanBuilder, branch };
yield return new object[] { bbanBuilder, bank };
yield return new object[] { ibanBuilder, bankAccount };
yield return new object[] { ibanBuilder, branch };
yield return new object[] { ibanBuilder, bank };
}
public static IEnumerable<object[]> TooShortWithPaddingTestCases()
{
Type bbanBuilder = typeof(BbanBuilder);
Type ibanBuilder = typeof(IbanBuilder);
Action<IBankAccountBuilder, string, bool> bankAccount = (b, value, pad) => b.WithBankAccountNumber(value, pad);
Action<IBankAccountBuilder, string, bool> branch = (b, value, pad) => b.WithBranchIdentifier(value, pad);
Action<IBankAccountBuilder, string, bool> bank = (b, value, pad) => b.WithBankIdentifier(value, pad);
yield return new object[] { bbanBuilder, bankAccount, "GB", "1", "000000000000000001" };
yield return new object[] { bbanBuilder, branch, "GB", "1", "000000000100000000" };
yield return new object[] { bbanBuilder, bank, "GB", "1", "000100000000000000" };
yield return new object[] { ibanBuilder, bankAccount, "GB", "1", "GB88000000000000000001" };
yield return new object[] { ibanBuilder, branch, "GB", "1", "GB62000000000100000000" };
yield return new object[] { ibanBuilder, bank, "GB", "1", "GB42000100000000000000" };
}
}
}
| 40.743494 | 161 | 0.593157 | [
"Apache-2.0"
] | French-Coders-Organization/IbanNet | test/IbanNet.Tests/Builders/BankAccountBuilderTests.cs | 10,962 | C# |
using System;
using System.Collections.Generic;
using System.Windows.Forms;
namespace HOH_DEMO
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
//// adicionar argv para obter o ficheiro a abrir
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Mainform());
}
}
}
| 23.73913 | 66 | 0.565934 | [
"MIT"
] | RManPT/HOH-DEMO | HOH_DEMO/Program.cs | 548 | C# |
using ADASMobileClient.Core.model;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
namespace ADASMobileClient.Core
{
[XamlCompilation(XamlCompilationOptions.Compile)]
public partial class CalibrationOrderSetupPage : ContentPage
{
private WorkOrderModel workOrderModel;
private string token;
private ObservableCollection<CalibrationDetailRow> multiSelectListItems;
HttpClient client;
/// <summary>
/// Object used to identify if the user tappep on a selected cell.
/// </summary>
private bool _isSelectedItemTap;
/// <summary>
/// Object holding the reference of current user selection.
/// </summary>
private int _selectedItemIndex;
private IList<CalibrationDetailRow> selectedItems = new List<CalibrationDetailRow>();
private string calid;
//public string CalId { get => calid; set => calid = value; }
private string idCallvar;
public CalibrationOrderSetupPage(string calId)
{
InitializeComponent();
BindingContext = this;
idCallvar = calId;
getDataBining();
}
private async void getDataBining()
{
multiSelectListItems = new ObservableCollection<CalibrationDetailRow>();
var httpClientHandler = new HttpClientHandler();
client = new HttpClient();
workOrderModel = new WorkOrderModel();
// token = Application.Current.Properties["token"].ToString();
try
{
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/text"));
// client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
// client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
//specify to use TLS 1.2 as default connection
// var id = "987654321ABCDEFG";
if (!string.IsNullOrEmpty(idCallvar))
{
var getResult = await client.GetAsync(Constants.LocalHost + "/api/entity/workorder/id/" + idCallvar);
if (getResult.IsSuccessStatusCode)
{
var response = await getResult.Content.ReadAsStringAsync();
var reqMonkeys = JsonConvert.DeserializeObject<WorkOrderModel>(response);
workOrderModel = reqMonkeys;
VinNumber.Text = workOrderModel.vinnumber;
WorkNumber.Text = workOrderModel.workorder;
ModelNumber.Text = workOrderModel.model;
Year.Text = workOrderModel.startdate;
TotalNoOfCalibration.Text = workOrderModel.totalcalibration;
NoOfCalibrationCompleted.Text = workOrderModel.numberofcalibrationcompleted;
MultiSelectListView.ItemsSource = workOrderModel.calibrationDetailRows;
}
}
else {
Debug.WriteLine("ID getting null ");
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception Error ", ex.ToString());
}
}
private void MultiSelectListView_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
}
private void MultiSelectListView_ItemTapped(object sender, ItemTappedEventArgs e)
{
}
}
} | 32.666667 | 135 | 0.590622 | [
"MIT"
] | ajaykeshri/AdasLogin | UserDetailsClient/UserDetailsClient.Core/CalibrationOrderSetupPage.xaml.cs | 4,118 | C# |
namespace Swisstalk.Foundation.Tasks
{
public enum TokenState
{
Undefined,
Active,
Cancelled,
Done
}
public static class TokenStateExtension
{
private static TokenState[] TaskStateToTokenStateMap = new TokenState[]
{
TokenState.Undefined, //Undefined = 0,
TokenState.Active, //Started,
TokenState.Active, //Running,
TokenState.Done,//Done,
TokenState.Done,//Stopped,
TokenState.Done//Disposed
};
public static bool IsActive(this TokenState state)
{
return (state == TokenState.Active);
}
public static bool IsComplete(this TokenState state)
{
return state.IsDone() || state.IsCancelled();
}
public static bool IsDone(this TokenState state)
{
return (state == TokenState.Done);
}
public static bool IsCancelled(this TokenState state)
{
return (state == TokenState.Cancelled);
}
public static TokenState ToTokenState(this TaskState taskState)
{
return TaskStateToTokenStateMap[(int)taskState];
}
public static TokenState GetMaxStateValue()
{
return TokenState.Cancelled;
}
}
}
| 25.018519 | 79 | 0.565507 | [
"MIT"
] | valentinivanov/swisstalk | code/Foundation/Tasks/TokenState.cs | 1,353 | C# |
using JiraAssistant.Domain.Ui;
namespace JiraAssistant.Pages
{
public partial class ApplicationSettings
{
private int _selectedIndex;
public ApplicationSettings()
{
InitializeComponent();
DataContext = this;
}
public ApplicationSettings(SettingsPage initialPage)
: this()
{
SelectedIndex = (int) initialPage;
}
public int SelectedIndex
{
get { return _selectedIndex; }
set
{
_selectedIndex = value;
RaisePropertyChanged();
}
}
public override string Title { get { return "Settings"; } }
}
}
| 19.647059 | 65 | 0.570359 | [
"MIT"
] | sceeter89/jira-client | JiraAssistant/Pages/ApplicationSettings.xaml.cs | 670 | C# |
using Windows.UI.Xaml.Controls;
// ReSharper disable ClassNeverInstantiated.Global
// ReSharper disable MemberCanBePrivate.Global
namespace Comet.UWP.Handlers
{
public class SpacerHandler : AbstractHandler<Spacer, Canvas>
{
protected override Canvas CreateView()
{
return new Canvas();
}
}
}
| 21.4375 | 64 | 0.682216 | [
"MIT"
] | PieEatingNinjas/Comet | src/Comet.UWP/Handlers/SpacerHandler.cs | 345 | C# |
using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
namespace HITUOISR.Toolkit.Settings
{
/// <summary>
/// 设置接口。
/// </summary>
public interface ISettings
{
/// <summary>
/// 获取具有指定键的设置子节。
/// </summary>
/// <param name="key">子节的键。</param>
/// <returns>对应的子节。</returns>
ISettingsSection GetSection(string key);
/// <summary>
/// 获取直接后代设置子节。
/// </summary>
/// <returns>子节列表。</returns>
IEnumerable<ISettingsSection> GetChildren();
/// <summary>
/// 为设置键指定一个值。
/// </summary>
/// <typeparam name="T">指定给键的对象的类型。</typeparam>
/// <param name="key">待设置的键。</param>
/// <param name="value">指派给键的值。</param>
/// <exception cref="MissingSettingsProviderException">缺少可用的提供器。</exception>
/// <exception cref="SettingsKeyNotFoundException">找不到对应的设置键。</exception>
/// <exception cref="SettingsReadOnlyExcepetion">设置键只读。</exception>
/// <exception cref="SettingsTypeMismatchException">设置类型不匹配。</exception>
void SetValue<T>(string key, T value);
/// <summary>
/// 获取指定键对应的设置值。
/// </summary>
/// <typeparam name="T">获取的对象的类型。</typeparam>
/// <param name="key">关联与请求获取的对象的键。</param>
/// <returns>获取的设置值。</returns>
/// <exception cref="SettingsKeyNotFoundException">找不到对应的设置键。</exception>
/// <exception cref="SettingsTypeMismatchException">设置类型不匹配。</exception>
[Pure]
T GetValue<T>(string key);
/// <summary>
/// 获取指定键对应的设置值。
/// </summary>
/// <typeparam name="T">获取的对象的类型。</typeparam>
/// <param name="key">关联与请求获取的对象的键。</param>
/// <param name="defaultGetter">获取默认值的委托。</param>
/// <returns>获取的设置值。</returns>
[Pure]
T GetValueOrElse<T>(string key, Func<T> defaultGetter);
}
}
| 33.101695 | 84 | 0.573989 | [
"MIT"
] | HIT-UOI-SR/HITUOISR.Toolkit | HITUOISR.Toolkit.Settings.Abstraction/src/ISettings.cs | 2,397 | C# |
// Copyright (c) 2021 Alachisoft
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License
using System.Reflection;
namespace Alachisoft.NCache.CacheHost
{
/// <summary>
/// Internal class that helps display assembly usage information.
/// </summary>
internal sealed class AssemblyUsage
{
/// <summary>
/// Displays logo banner
/// </summary>
/// <param name="printlogo">Specifies whether to print logo or not</param>
public static void PrintLogo(bool printlogo)
{
Assembly assembly = Assembly.GetExecutingAssembly();
string logo = @"Alachisoft (R) NCache Utility CacheSeparateHost. Version " + assembly.GetName().Version +
@"
Copyright (C) Alachisoft 2015. All rights reserved.";
if (printlogo)
{
System.Console.WriteLine(logo);
System.Console.WriteLine();
}
}
/// <summary>
/// Displays assembly usage information.
/// </summary>
static public void PrintUsage()
{
string usage = @"Usage: CacheSeparateHost [option[...]].
/i /cachename
Specifies the id/name of cache.
/f /configfile
Specifies the config file path.
/p /cacheport
Specifies the client port on cache will start.
/?
Displays a detailed help screen
";
System.Console.WriteLine(usage);
}
}
}
| 28.478261 | 117 | 0.624936 | [
"Apache-2.0"
] | Alachisoft/NCache | Src/NCCacheSeparateHost/Properties/AssemblyUsage.cs | 1,967 | C# |
using System;
namespace Ryujinx.Graphics
{
static class QuadHelper
{
public static int ConvertSizeQuadsToTris(int size)
{
return size <= 0 ? 0 : (size / 4) * 6;
}
public static int ConvertSizeQuadStripToTris(int size)
{
return size <= 1 ? 0 : ((size - 2) / 2) * 6;
}
public static byte[] ConvertQuadsToTris(byte[] data, int entrySize, int count)
{
int primitivesCount = count / 4;
int quadPrimSize = 4 * entrySize;
int trisPrimSize = 6 * entrySize;
byte[] output = new byte[primitivesCount * 6 * entrySize];
for (int prim = 0; prim < primitivesCount; prim++)
{
void AssignIndex(int src, int dst, int copyCount = 1)
{
src = prim * quadPrimSize + src * entrySize;
dst = prim * trisPrimSize + dst * entrySize;
Buffer.BlockCopy(data, src, output, dst, copyCount * entrySize);
}
//0 1 2 -> 0 1 2.
AssignIndex(0, 0, 3);
//2 3 -> 3 4.
AssignIndex(2, 3, 2);
//0 -> 5.
AssignIndex(0, 5);
}
return output;
}
public static byte[] ConvertQuadStripToTris(byte[] data, int entrySize, int count)
{
int primitivesCount = (count - 2) / 2;
int quadPrimSize = 2 * entrySize;
int trisPrimSize = 6 * entrySize;
byte[] output = new byte[primitivesCount * 6 * entrySize];
for (int prim = 0; prim < primitivesCount; prim++)
{
void AssignIndex(int src, int dst, int copyCount = 1)
{
src = prim * quadPrimSize + src * entrySize + 2 * entrySize;
dst = prim * trisPrimSize + dst * entrySize;
Buffer.BlockCopy(data, src, output, dst, copyCount * entrySize);
}
//-2 -1 0 -> 0 1 2.
AssignIndex(-2, 0, 3);
//0 1 -> 3 4.
AssignIndex(0, 3, 2);
//-2 -> 5.
AssignIndex(-2, 5);
}
return output;
}
}
} | 28.580247 | 90 | 0.456156 | [
"Unlicense"
] | huangweiboy/Ryujinx | Ryujinx.Graphics/QuadHelper.cs | 2,315 | C# |
//Public Method to retrieve the bot config (Will also create a new one if one is not found)
public BotConfig GetBotConfig(string filepath)
=> FetchOrCreateBotConfig(filepath);
//Public Method can be used to overwrite the botconfig if required.
public void SaveBotConfig(BotConfig config, string filepath)
=> WriteBotConfig(config, filepath);
//Simple Method to check if the config.json exists.
private bool Exists(string filepath)
{
if(File.Exists(filepath))
return true;
return false;
}
//Method to either fetch the BotConfig or create a new blank config for you to fill in.
//Exits the application if a config doesn't already exist.
private BotConfig FetchOrCreateBotConfig(string filepath)
{
if (Exists(filepath))
{
var rawData - GetRawData(filepath);
return JsonConvert.DeserializeObject<BotConfig>(rawData);
}
Console.WriteLine("New Config.json found." +
$"\nA new One has been created at: {Directory.GetCurrentDirectory()}");
var newConfig = GenNewBotConfig();
WriteBotConfig(newConfig, filepath);
Console.ReadLine();
Environment.Exit(0);
}
//Read the config file and return it as a string.
private string GetRawData(string filepath)
=> File.ReadAllText(filepath);
//Write the config data to the config.json.
private void WriteBotConfig(BotConfig config, string filepath)
{
var rawData = SerializeBotConfig(config)
File.WriteAllText(filepath, rawData, Encoding.UTF8);
}
// Serialize The BotConfig Object into a string ready to write to the file.
private string SerializeBotConfig(BotConfig config)
=> JsonConvert.SerializeObject(config, Formatting.Indented);
//Generate a config template for you to fill in.
private BotConfig GenNewBotConfig()
=> new BotConfig
{
Token = "CHANGE ME TO YOUR TOKEN",
GameStatus = "CHANGE ME TO A STATUS",
Prefix = "!"
};
| 33 | 93 | 0.718391 | [
"MIT"
] | Charly6596/common-issues | DotNet-Addons/JSON-Storage/BotConfigExample/DataStorage.cs | 1,914 | C# |
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Microsoft.VsSDK.IntegrationTestLibrary;
using Microsoft.VSSDK.Tools.VsIdeTesting;
namespace VsExt.AutoShelve_IntegrationTests
{
[TestClass]
public class CSharpProjectTests
{
#region fields
private delegate void ThreadInvoker();
#endregion
#region properties
/// <summary>
/// Gets or sets the test context which provides
/// information about and functionality for the current test run.
/// </summary>
public TestContext TestContext { get; set; }
#endregion
#region ctors
#endregion
#region Additional test attributes
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
[TestMethod]
[HostType("VS IDE")]
public void WinformsApplication()
{
UIThreadInvoker.Invoke((ThreadInvoker) delegate
{
var testUtils = new TestUtils();
testUtils.CreateEmptySolution(TestContext.TestDir, "CSWinApp");
Assert.AreEqual(0, testUtils.ProjectCount());
//Create Winforms application project
//TestUtils.CreateProjectFromTemplate("MyWindowsApp", "Windows Application", "CSharp", false);
//Assert.AreEqual<int>(1, TestUtils.ProjectCount());
});
}
}
} | 30.197183 | 110 | 0.596549 | [
"MIT"
] | Sockenfresser/tfsautoshelve | VsExt.AutoShelve/VsExt.AutoShelve_IntegrationTests/SignOff-Tests/CSharpProjectTests.cs | 2,146 | C# |
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Immutable;
using Microsoft.VisualStudio.Imaging.Interop;
using Microsoft.VisualStudio.ProjectSystem.VS.Tree.Dependencies.Snapshot;
namespace Microsoft.VisualStudio.ProjectSystem.VS.Tree.Dependencies.Models
{
internal interface IDependencyViewModel
{
string Caption { get; }
string FilePath { get; }
string SchemaName { get; }
string SchemaItemType { get; }
int Priority { get; }
ImageMoniker Icon { get; }
ImageMoniker ExpandedIcon { get; }
IImmutableDictionary<string, string> Properties { get; }
ProjectTreeFlags Flags { get; }
IDependency OriginalModel { get; }
}
}
| 35.458333 | 161 | 0.699177 | [
"Apache-2.0"
] | 333fred/roslyn-project-system | src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/Tree/Dependencies/Models/IDependencyViewModel.cs | 853 | C# |
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using System;
using System.Security.Claims;
namespace Microsoft.Identity.Web
{
/// <summary>
/// Extensions around ClaimsPrincipal.
/// </summary>
public static class ClaimsPrincipalExtensions
{
/// <summary>
/// Gets the Account identifier for an MSAL.NET account from a <see cref="ClaimsPrincipal"/>.
/// </summary>
/// <param name="claimsPrincipal">Claims principal.</param>
/// <returns>A string corresponding to an account identifier as defined in <see cref="Microsoft.Identity.Client.AccountId.Identifier"/>.</returns>
public static string GetMsalAccountId(this ClaimsPrincipal claimsPrincipal)
{
string userObjectId = claimsPrincipal.GetObjectId();
string nameIdentifierId = claimsPrincipal.GetNameIdentifierId();
string tenantId = claimsPrincipal.GetTenantId();
string userFlowId = claimsPrincipal.GetUserFlowId();
if (!string.IsNullOrWhiteSpace(nameIdentifierId) &&
!string.IsNullOrWhiteSpace(tenantId) &&
!string.IsNullOrWhiteSpace(userFlowId))
{
// B2C pattern: {oid}-{userFlow}.{tid}
return $"{nameIdentifierId}.{tenantId}";
}
else if (!string.IsNullOrWhiteSpace(userObjectId) && !string.IsNullOrWhiteSpace(tenantId))
{
// AAD pattern: {oid}.{tid}
return $"{userObjectId}.{tenantId}";
}
return null;
}
/// <summary>
/// Gets the unique object ID associated with the <see cref="ClaimsPrincipal"/>.
/// </summary>
/// <param name="claimsPrincipal">the <see cref="ClaimsPrincipal"/> from which to retrieve the unique object ID.</param>
/// <remarks>This method returns the object ID both in case the developer has enabled or not claims mapping.</remarks>
/// <returns>Unique object ID of the identity, or <c>null</c> if it cannot be found.</returns>
public static string GetObjectId(this ClaimsPrincipal claimsPrincipal)
{
string userObjectId = claimsPrincipal.FindFirstValue(ClaimConstants.Oid);
if (string.IsNullOrEmpty(userObjectId))
{
userObjectId = claimsPrincipal.FindFirstValue(ClaimConstants.ObjectId);
}
return userObjectId;
}
/// <summary>
/// Gets the Tenant ID associated with the <see cref="ClaimsPrincipal"/>.
/// </summary>
/// <param name="claimsPrincipal">the <see cref="ClaimsPrincipal"/> from which to retrieve the tenant ID.</param>
/// <returns>Tenant ID of the identity, or <c>null</c> if it cannot be found.</returns>
/// <remarks>This method returns the tenant ID both in case the developer has enabled or not claims mapping.</remarks>
public static string GetTenantId(this ClaimsPrincipal claimsPrincipal)
{
string tenantId = claimsPrincipal.FindFirstValue(ClaimConstants.Tid);
if (string.IsNullOrEmpty(tenantId))
{
return claimsPrincipal.FindFirstValue(ClaimConstants.TenantId);
}
return tenantId;
}
/// <summary>
/// Gets the login-hint associated with a <see cref="ClaimsPrincipal"/>.
/// </summary>
/// <param name="claimsPrincipal">Identity for which to complete the login-hint.</param>
/// <returns>login-hint for the identity, or <c>null</c> if it cannot be found.</returns>
public static string GetLoginHint(this ClaimsPrincipal claimsPrincipal)
{
return GetDisplayName(claimsPrincipal);
}
/// <summary>
/// Gets the domain-hint associated with an identity.
/// </summary>
/// <param name="claimsPrincipal">Identity for which to compute the domain-hint.</param>
/// <returns>domain-hint for the identity, or <c>null</c> if it cannot be found.</returns>
public static string GetDomainHint(this ClaimsPrincipal claimsPrincipal)
{
// Tenant for MSA accounts
const string msaTenantId = "9188040d-6c67-4c5b-b112-36a304b66dad";
var tenantId = GetTenantId(claimsPrincipal);
string domainHint = string.IsNullOrWhiteSpace(tenantId)
? null
: tenantId.Equals(msaTenantId, StringComparison.OrdinalIgnoreCase) ? "consumers" : "organizations";
return domainHint;
}
/// <summary>
/// Get the display name for the signed-in user, from the <see cref="ClaimsPrincipal"/>.
/// </summary>
/// <param name="claimsPrincipal">Claims about the user/account.</param>
/// <returns>A string containing the display name for the user, as determined by Azure AD (v1.0) and Microsoft identity platform (v2.0) tokens,
/// or <c>null</c> if the claims cannot be found.</returns>
/// <remarks>See https://docs.microsoft.com/azure/active-directory/develop/id-tokens#payload-claims. </remarks>
public static string GetDisplayName(this ClaimsPrincipal claimsPrincipal)
{
// Use the claims in a Microsoft identity platform token first
string displayName = claimsPrincipal.FindFirstValue(ClaimConstants.PreferredUserName);
if (!string.IsNullOrWhiteSpace(displayName))
{
return displayName;
}
// Otherwise fall back to the claims in an Azure AD v1.0 token
displayName = claimsPrincipal.FindFirstValue(ClaimsIdentity.DefaultNameClaimType);
if (!string.IsNullOrWhiteSpace(displayName))
{
return displayName;
}
// Finally falling back to name
return claimsPrincipal.FindFirstValue(ClaimConstants.Name);
}
/// <summary>
/// Gets the user flow id associated with the <see cref="ClaimsPrincipal"/>.
/// </summary>
/// <param name="claimsPrincipal">the <see cref="ClaimsPrincipal"/> from which to retrieve the user flow id.</param>
/// <returns>User Flow Id of the identity, or <c>null</c> if it cannot be found.</returns>
public static string GetUserFlowId(this ClaimsPrincipal claimsPrincipal)
{
string userFlowId = claimsPrincipal.FindFirstValue(ClaimConstants.Tfp);
if (string.IsNullOrEmpty(userFlowId))
{
return claimsPrincipal.FindFirstValue(ClaimConstants.UserFlow);
}
return userFlowId;
}
/// <summary>
/// Gets the NameIdentifierId associated with the <see cref="ClaimsPrincipal"/>.
/// </summary>
/// <param name="claimsPrincipal">the <see cref="ClaimsPrincipal"/> from which to retrieve the sub claim.</param>
/// <returns>Name identifier ID (sub) of the identity, or <c>null</c> if it cannot be found.</returns>
public static string GetNameIdentifierId(this ClaimsPrincipal claimsPrincipal)
{
return claimsPrincipal.FindFirstValue(ClaimConstants.UniqueObjectIdentifier);
}
}
}
| 45.73125 | 154 | 0.62717 | [
"MIT"
] | jg11jg/microsoft-identity-web | src/Microsoft.Identity.Web/ClaimsPrincipalExtensions.cs | 7,319 | C# |
/* ****************************************************************************
*
* Copyright (c) Mårten Rånge.
*
* This source code is subject to terms and conditions of the Microsoft Public License. A
* copy of the license can be found in the License.html file at the root of this distribution. If
* you cannot locate the Microsoft Public License, please send an email to
* dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
* by the terms of the Microsoft Public License.
*
* You must not remove this notice, or any other, from this software.
*
*
* ***************************************************************************/
using System;
using System.Runtime.InteropServices;
namespace WpfShaderEffects.DirectX.Interop
{
[ComImport]
[Guid("51b8a949-1a31-47e6-bea0-4b30db53f1e0")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
interface ID3DXEffectCompilerCustom
{
//[PreserveSig] HRESULT QueryInterface;
//[PreserveSig] HRESULT AddRef;
//[PreserveSig] HRESULT Release;
[PreserveSig]
Int32 GetDesc(out D3DXEFFECT_DESC desc);
[PreserveSig]
Int32 GetParameterDesc(
IntPtr parameterHandle,
out D3DXPARAMETER_DESC desc);
[PreserveSig]
Int32 GetTechniqueDesc(
IntPtr techniqueHandle,
out D3DXTECHNIQUE_DESC desc);
[PreserveSig]
Int32 GetPassDesc(
IntPtr passHandle,
out D3DXPASS_DESC desc);
[PreserveSig]
Int32 GetFunctionDesc(
IntPtr functionHandle,
out D3DXFUNCTION_DESC desc);
// Handle operations
[PreserveSig]
IntPtr GetParameter(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
uint index);
[PreserveSig]
IntPtr GetParameterByName(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPStr)] string name);
[PreserveSig]
IntPtr GetParameterBySemantic(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPStr)] string semantic);
[PreserveSig]
IntPtr GetParameterElement(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
uint index);
[PreserveSig]
IntPtr GetTechnique(uint index);
[PreserveSig]
IntPtr GetTechniqueByName([MarshalAs(UnmanagedType.LPStr)] string name);
[PreserveSig]
IntPtr GetPass(
[MarshalAs(UnmanagedType.LPStr)] string techniqueHandle,
uint index);
[PreserveSig]
IntPtr GetPassByName(
[MarshalAs(UnmanagedType.LPStr)] string techniqueHandle,
[MarshalAs(UnmanagedType.LPStr)] string name);
[PreserveSig]
IntPtr GetFunction(uint index);
[PreserveSig]
IntPtr GetFunctionByName([MarshalAs(UnmanagedType.LPStr)] string name);
[PreserveSig]
IntPtr GetAnnotation(
IntPtr objectHandle,
uint index);
[PreserveSig]
IntPtr GetAnnotationByName(
IntPtr objectHandle,
[MarshalAs(UnmanagedType.LPStr)] string name);
[PreserveSig]
Int32 SetValue(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
IntPtr data,
uint bytes);
[PreserveSig]
Int32 GetValue(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
IntPtr data,
uint bytes);
[PreserveSig]
Int32 SetBool(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.Bool)] bool b);
[PreserveSig]
Int32 GetBool(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.Bool)] out bool b);
[PreserveSig]
Int32 SetBoolArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Bool,
SizeParamIndex = 2)] bool[] b,
uint count);
[PreserveSig]
Int32 GetBoolArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Bool,
SizeParamIndex = 2)] out bool[] b,
uint count);
[PreserveSig]
Int32 SetInt(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
int b);
[PreserveSig]
Int32 GetInt(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
out int b);
[PreserveSig]
Int32 SetIntArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] int[] n,
uint count);
[PreserveSig]
Int32 GetIntArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] out int[] n,
uint count);
[PreserveSig]
Int32 SetFloat(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
float b);
[PreserveSig]
Int32 GetFloat(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
out float b);
[PreserveSig]
Int32 SetFloatArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] float[] n,
uint count);
[PreserveSig]
Int32 GetFloatArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] out float[] n,
uint count);
[PreserveSig]
Int32 SetVector(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] ref D3DXVector4 b);
[PreserveSig]
Int32 GetVector(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
out D3DXVector4 b);
[PreserveSig]
Int32 SetVectorArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] D3DXVector4[] n,
uint count);
[PreserveSig]
Int32 GetVectorArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] out
D3DXVector4[] n,
uint count);
[PreserveSig]
Int32 SetMatrix(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] ref D3DXMatrix16 b);
[PreserveSig]
Int32 GetMatrix(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
out D3DXMatrix16 b);
[PreserveSig]
Int32 SetMatrixArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] D3DXMatrix16[] n,
uint count);
[PreserveSig]
Int32 GetMatrixArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] out
D3DXMatrix16[] n,
uint count);
[PreserveSig]
Int32 SetMatrixPointerArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] IntPtr[] n,
uint count);
[PreserveSig]
Int32 GetMatrixPointerArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] out IntPtr[] n,
uint count);
[PreserveSig]
Int32 SetMatrixTranspose(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] ref D3DXMatrix16 b);
[PreserveSig]
Int32 GetMatrixTranspose(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
out D3DXMatrix16 b);
[PreserveSig]
Int32 SetMatrixTransposeArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] D3DXMatrix16[] n,
uint count);
[PreserveSig]
Int32 GetMatrixTransposeArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] out
D3DXMatrix16[] n,
uint count);
[PreserveSig]
Int32 SetMatrixTransposePointerArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] IntPtr[] n,
uint count);
[PreserveSig]
Int32 GetMatrixTransposePointerArray(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] out IntPtr[] n,
uint count);
[PreserveSig]
Int32 SetString(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[In] [MarshalAs(UnmanagedType.LPStr)] string name);
[PreserveSig]
Int32 GetString(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.LPStr)] out string name);
[PreserveSig]
Int32 SetTexture(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
IntPtr texture);
[PreserveSig]
Int32 GetTexture(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
out IntPtr texture);
[PreserveSig]
Int32 GetPixelShader(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
out IDirect3DPixelShader9 pixelShader);
[PreserveSig]
Int32 GetVertexShader(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
out IDirect3DVertexShader9 vertexShader);
[PreserveSig]
Int32 SetArrayRange(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
uint start,
uint end);
//// ID3DXBaseEffect
//// Parameter sharing, specialization, and information
[PreserveSig]
Int32 SetLiteral(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.Bool)] bool literal);
[PreserveSig]
Int32 GetLiteral(
[MarshalAs(UnmanagedType.LPStr)] string parameterHandle,
[MarshalAs(UnmanagedType.Bool)] out bool literal);
//// Compilation
[PreserveSig]
Int32 CompileEffect(
D3DXSHADER flags,
out ID3DXBuffer effect,
out ID3DXBuffer errorMsgs);
[PreserveSig]
Int32 CompileShader(
[MarshalAs(UnmanagedType.LPStr)] string function,
[MarshalAs(UnmanagedType.LPStr)] string target,
D3DXSHADER flags,
out ID3DXBuffer shader,
out ID3DXBuffer errorMsgs,
out ID3DXConstantTable constantTable);
}
} | 31.46087 | 98 | 0.641515 | [
"MIT"
] | mrange/WpfShaderEffect | src/CsDxEffectCompiler/Interop/ID3DXEffectCompilerCustom.cs | 10,858 | C# |
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System;
using System.IO;
public class MiscEditorHelpers {
static public string SaveScriptableObjectAtCurrentFolder<T>(T sObj, string fileNameAndExt) where T:ScriptableObject {
return MiscEditorHelpers.SaveScriptableObjectAtFolder<T>(sObj, MiscEditorHelpers.GetActiveProjectFolderPath(), fileNameAndExt);
}
static public string SaveScriptableObjectAtFolder<T>(T sObj, string parentFolder, string fileNameAndExt) where T:ScriptableObject {
if (!fileNameAndExt.Contains(".")) fileNameAndExt += ".asset";
string rawPath = parentFolder.Trim('/', '\\') + "/" + fileNameAndExt;
//Debug.Log("generating unique asset name from: '" + rawPath + "'...");
string uPath = AssetDatabase.GenerateUniqueAssetPath(rawPath);
//Debug.Log("creating asset at: " + uPath);
AssetDatabase.CreateAsset(sObj, uPath);
AssetDatabase.SaveAssets();
Selection.activeObject = sObj;
EditorGUIUtility.PingObject(sObj);
return uPath;
}
static public string GetActiveProjectFolderPath() {
//attempt to get active ProjectView folder else Assets root..
string pwDir = "Assets";
UnityEngine.Object obj = Selection.activeObject;
if (obj != null) {
pwDir = GetUnityObjectFolderPath(obj);
if (!pwDir.StartsWith("Assets", StringComparison.CurrentCulture)) pwDir = "Assets"; // check incase the active object was a system object outside assets folder (illegal)..
}
return pwDir;
}
static public string GetUnityObjectFolderPath(UnityEngine.Object obj) {
string path = "";
string selPath = AssetDatabase.GetAssetPath(obj.GetInstanceID());
if (!string.IsNullOrEmpty(selPath)) {
if (Directory.Exists(selPath)) {
path = selPath;
} else {
//trim file name..
path = selPath.Substring(0, selPath.LastIndexOf('/'));
}
}
return path;
}
}
| 29.957746 | 183 | 0.650682 | [
"MIT"
] | Mann1ng/EtheriaEmergentBehaviourFramework | Assets/Etheria/Scripts/Editor/MiscEditorHelpers.cs | 2,127 | C# |
using System;
namespace CodeUtopia.Messages
{
public interface IEntityEvent : IDomainEvent
{
Guid EntityId { get; }
}
} | 15.666667 | 48 | 0.652482 | [
"MIT"
] | andrewgunn/CodeUtopia | CodeUtopia.Messages/IEntityEvent.cs | 143 | C# |
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
using Newtonsoft.Json;
namespace PointOfInterestSkill.Models
{
public class SearchResult
{
[JsonProperty(PropertyName = "id")]
public string Id { get; set; }
/// <summary>
/// Gets ResultType string: POI, Street, Geography, Point Address, Address Range, and Cross Street.
/// </summary>
[JsonProperty(PropertyName = "type")]
public string ResultType { get; set; }
[JsonProperty(PropertyName = "address")]
public SearchAddress Address { get; set; }
[JsonProperty(PropertyName = "position")]
public LatLng Position { get; set; }
[JsonProperty(PropertyName = "poi")]
public PoiInfo Poi { get; set; }
[JsonProperty(PropertyName = "viewport")]
public Viewport Viewport { get; set; }
}
} | 29.580645 | 107 | 0.623773 | [
"MIT"
] | adamstephensen/AI | solutions/Virtual-Assistant/src/csharp/skills/pointofinterestskill/pointofinterestskill/Models/AzureMaps/SearchResult.cs | 919 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Supercode.Blazor.Toolbar;
namespace BlazorServerSide.Toolbars
{
public class ActionToolbar : Toolbar
{
}
}
| 17.307692 | 41 | 0.76 | [
"MIT"
] | cschulzsuper/blazor-toolbar | samples/BlazorServerSide/Toolbars/_ActionToolbar.cs | 227 | C# |
using CDT.Cosmos.Cms.Common.Data.Logic;
using CDT.Cosmos.Cms.Data.Logic;
using CDT.Cosmos.Cms.Models;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace Cosmos.Tests
{
/// <summary>
/// Tests the <see cref="ArticleEditLogic" /> functions independent of controllers.
/// </summary>
[TestClass]
public class CORE_F01_ArticleEditLogicTests
{
private static Utilities? utils;
private static IdentityUser? _testUser;
[ClassInitialize]
public static void Initialize(TestContext context)
{
//
// Setup context.
//
utils = new Utilities();
using var dbContext = utils.GetApplicationDbContext();
_testUser = utils.GetIdentityUser(TestUsers.Foo).Result;
dbContext.ArticleLogs.RemoveRange(dbContext.ArticleLogs.ToList());
dbContext.Articles.RemoveRange(dbContext.Articles.ToList());
dbContext.SaveChanges();
}
/// <summary>
/// Test the creation of root page, and, version it.
/// </summary>
[TestMethod]
public async Task A_Create_And_Save_Root()
{
await using var dbContext = utils.GetApplicationDbContext();
var logic = utils.GetArticleEditLogic(dbContext);
var rootModel = await logic.Create($"New Title {Guid.NewGuid().ToString()}");
Assert.AreEqual(0, rootModel.Id);
Assert.AreEqual(0, rootModel.VersionNumber);
//rootModel.Title = Guid.NewGuid().ToString();
rootModel.Content = Guid.NewGuid().ToString();
rootModel.Published = DateTime.Now;
//
// CREATE THE HOME (ROOT) PAGE.
//
var homePage = await logic.UpdateOrInsert(rootModel, _testUser.Id);
//var articles = await _dbContext.Articles.ToListAsync();
Assert.IsNotNull(homePage);
Assert.IsInstanceOfType(homePage, typeof(ArticleUpdateResult));
Assert.IsTrue(0 < homePage.Model.Id);
Assert.AreEqual(1, homePage.Model.VersionNumber);
//Assert.AreEqual("root", homePage.UrlPath);
Assert.IsTrue(homePage.Model.Published.HasValue);
//
// Check other properties
//
Assert.AreEqual(rootModel.Title, homePage.Model.Title);
Assert.AreEqual(rootModel.Content, homePage.Model.Content);
//
// Check Logs
//
var logs = await dbContext.ArticleLogs.Where(l => l.ArticleId == homePage.Model.Id).ToListAsync();
Assert.AreEqual(4, logs.Count);
}
[TestMethod]
public async Task B_Get_Home_Page()
{
// ARRANGE
// New db context
await using var dbContext = utils.GetApplicationDbContext();
// Ensure root exists
Assert.AreEqual(1, await dbContext.Articles.CountAsync());
var root = await dbContext.Articles.FirstOrDefaultAsync();
Assert.AreEqual("root", root.UrlPath);
// Now build the logic
var logic = utils.GetArticleEditLogic(dbContext);
//
// All four should find the home page.
//
var test1 = await logic.GetByUrl(null);
Assert.IsNotNull(test1);
var test2 = await logic.GetByUrl("");
Assert.IsNotNull(test2);
var test3 = await logic.GetByUrl("/");
Assert.IsNotNull(test3);
var test4 = await logic.GetByUrl(" ");
Assert.IsNotNull(test4);
Assert.AreEqual(test1.Id, test2.Id);
Assert.AreEqual(test1.Id, test3.Id);
Assert.AreEqual(test1.Id, test4.Id);
}
[TestMethod]
public async Task C_Add_Versions_Some_Published()
{
await using var dbContext = utils.GetApplicationDbContext();
var logic = utils.GetArticleEditLogic(dbContext);
//var article = await _dbContext.Articles.FirstOrDefaultAsync(w => w.UrlPath == "ROOT");
//var articles = await _dbContext.Articles.ToListAsync();
var version1 = await logic.GetByUrl("");
// Make changes to version 1
version1.VersionNumber = 0; // Trigger new version
version1.Published = null; // Not published
// Save work, now should have new version number
var version2 = await logic.UpdateOrInsert(version1, _testUser.Id);
//Assert.AreEqual(2, version2.VersionNumber);
Assert.IsFalse(version2.Model.Published.HasValue);
// Make a third version, still unpublished, now change to published
version2.Model.VersionNumber = 0;
var version3 = await logic.UpdateOrInsert(version2.Model, _testUser.Id);
Assert.AreEqual(3, version3.Model.VersionNumber);
Assert.IsFalse(version3.Model.Published.HasValue);
// Fourth version. Third one is published, but new versions are UNPUBLISHED by default.
version3.Model.Published = DateTime.Now;
version3.Model.VersionNumber = 0;
var version4 = await logic.UpdateOrInsert(version3.Model, _testUser.Id);
Assert.AreEqual(4, version4.Model.VersionNumber);
Assert.IsFalse(version4.Model.Published.HasValue);
// Now set to un published for version 5
version4.Model.Published = null;
version4.Model.VersionNumber = 0;
// Make a third version, still unpublished, now change to published
var version5 = await logic.UpdateOrInsert(version4.Model, _testUser.Id);
Assert.AreEqual(5, version5.Model.VersionNumber);
Assert.IsFalse(version5.Model.Published.HasValue);
var versions = await dbContext.Articles
.Where(a => a.ArticleNumber == version5.Model.ArticleNumber).ToListAsync();
Assert.AreEqual(5, versions.Count);
}
[TestMethod]
public async Task C_Get_Last_Published_Version()
{
await using var dbContext = utils.GetApplicationDbContext();
var logic = utils.GetArticleEditLogic(dbContext);
var article = await logic.GetByUrl("");
var article1 = article;
var lastPublishedArticle = await dbContext.Articles
.Where(p => p.Published != null && p.ArticleNumber == article1.ArticleNumber)
.OrderByDescending(o => o.VersionNumber).FirstOrDefaultAsync();
//var lastArticlePeriod = await _dbContext.Articles.Where(p => p.ArticleNumber == article.ArticleNumber).OrderByDescending(o => o.VersionNumber).FirstOrDefaultAsync();
Assert.AreEqual(lastPublishedArticle.ArticleNumber, article.ArticleNumber);
Assert.AreEqual(lastPublishedArticle.VersionNumber,
article.VersionNumber); // VERSION 4 is NOT PUBLISHED!! .
var articleNumber = article.ArticleNumber;
var versionNumber = article.VersionNumber;
// Now get the very last version, unpublished or not.
article = await logic.GetByUrl("", "en-US", false);
Assert.AreEqual(articleNumber, article.ArticleNumber);
Assert.AreNotEqual(versionNumber, article.VersionNumber);
}
[TestMethod]
public async Task D_Create_New_Article_Versions_TestRedirect_Publish()
{
await using var dbContext = utils.GetApplicationDbContext();
var logic = utils.GetArticleEditLogic(dbContext);
var articleNumbers = await dbContext.Articles.Select(s => new
{
s.Id,
s.ArticleNumber,
s.VersionNumber
}).ToListAsync();
var nextArticleNumber = articleNumbers.Max(m => m.ArticleNumber) + 1;
//
// Create and save version 1
var version1 = await logic.UpdateOrInsert(await logic.Create("This is a second page" + Guid.NewGuid()),
_testUser.Id);
Assert.AreEqual(1, version1.Model.VersionNumber);
Assert.AreEqual(nextArticleNumber, version1.Model.ArticleNumber);
//
// Make a change to version 1, and save as an update (don't create a new version)
version1.Model.Content = Guid.NewGuid() + "WOW";
var ver1OriginalContent = version1.Model.Content;
var version1UpdateA = await logic.UpdateOrInsert(version1.Model, _testUser.Id);
Assert.AreEqual(version1.Model.Content, version1UpdateA.Model.Content);
Assert.AreEqual(1, version1UpdateA.Model.VersionNumber);
//
// Make a change to version 1, and save as an update (don't create a new version)
version1UpdateA.Model.Content = Guid.NewGuid() + "NOW";
var version1UpdateB = await logic.UpdateOrInsert(version1UpdateA.Model, _testUser.Id);
Assert.AreEqual(version1UpdateA.Model.Content, version1UpdateB.Model.Content);
Assert.AreNotEqual(version1.Model.Content, version1UpdateB.Model.Content);
Assert.AreEqual(1, version1UpdateB.Model.VersionNumber);
//
// Make a new version (version 2)
version1UpdateB.Model.Published = null;
version1UpdateB.Model.VersionNumber = 0;
var version2 = await logic.UpdateOrInsert(version1UpdateB.Model, _testUser.Id);
Assert.AreEqual(2, version2.Model.VersionNumber);
Assert.AreEqual(version1UpdateB.Model.Content, version2.Model.Content);
//
// Create a new version, and change the title.
// This should trigger a redirect record being created.
//
version2.Model.Title = "New Version " + Guid.NewGuid(); // Change the title
version2.Model.VersionNumber = 0; // Make a version 3
version2.Model.Published = DateTime.Now; // New version published.
//
// This should change the title, create a redirect record as well.
//
var titleChangeVersion3 = await logic.UpdateOrInsert(version2.Model, _testUser.Id);
Assert.AreEqual(3, titleChangeVersion3.Model.VersionNumber);
// Even though version 2 is published, new versions should NEVER be published.
Assert.IsFalse(titleChangeVersion3.Model.Published.HasValue);
Assert.AreEqual(titleChangeVersion3.Model.Title, version2.Model.Title);
Assert.AreNotEqual(version1.Model.Title, version2.Model.Title);
titleChangeVersion3.Model.VersionNumber = 0; // Make version 4
var version4 = await logic.UpdateOrInsert(titleChangeVersion3.Model, _testUser.Id);
Assert.AreEqual(4, version4.Model.VersionNumber);
//
// Test redirect
//
//var list = await _dbContext.Articles.Where(w => w.StatusCode == 3).ToListAsync();
var redirectResult = await logic.GetByUrl(version2.Model.UrlPath);
Assert.AreEqual(StatusCodeEnum.Redirect, redirectResult.StatusCode);
// In a redirect, the content is the new URL path.
Assert.AreEqual(redirectResult.Content, titleChangeVersion3.Model.UrlPath);
//
// Get all four versions
//
var testVersion1 = dbContext.Articles.Include(i => i.ArticleLogs)
.FirstOrDefault(f => f.ArticleNumber == 2 && f.VersionNumber == 1);
var testVersion2 = dbContext.Articles.Include(i => i.ArticleLogs)
.FirstOrDefault(f => f.ArticleNumber == 2 && f.VersionNumber == 2);
var testVersion3 = dbContext.Articles.Include(i => i.ArticleLogs)
.FirstOrDefault(f => f.ArticleNumber == 2 && f.VersionNumber == 3);
var testVersion4 = dbContext.Articles.Include(i => i.ArticleLogs)
.FirstOrDefault(f => f.ArticleNumber == 2 && f.VersionNumber == 4);
Assert.IsNotNull(testVersion1);
Assert.IsNotNull(testVersion2);
Assert.IsNotNull(testVersion3);
Assert.IsNotNull(testVersion4);
// Test Version 1
// Changing title, changes it for all versions of the same Article Number
Assert.IsTrue(testVersion1.Title.Contains("New Version"));
Assert.IsFalse(testVersion1.Published.HasValue);
Assert.AreEqual(1, testVersion1.VersionNumber);
Assert.AreEqual(2, testVersion1.ArticleNumber);
Assert.AreNotEqual(ver1OriginalContent, testVersion1.Content); // Last change made.
// Test Version 1 Logs
Assert.IsTrue(testVersion1.ArticleLogs.Any(a => a.IdentityUserId == _testUser.Id &&
a.ActivityNotes.Contains("New article",
StringComparison.CurrentCultureIgnoreCase)));
Assert.IsTrue(testVersion1.ArticleLogs.Any(a => a.IdentityUserId == _testUser.Id &&
a.ActivityNotes.Contains("New version",
StringComparison.CurrentCultureIgnoreCase)));
Assert.AreEqual(2, testVersion1.ArticleLogs.Count(a => a.IdentityUserId == _testUser.Id &&
a.ActivityNotes == "Edit existing"));
Assert.AreEqual(4, testVersion1.ArticleLogs.Count);
// Test Version 2
//Assert.AreEqual("New Version", testVersion2.Title);
Assert.IsFalse(testVersion2.Published.HasValue);
Assert.AreEqual(2, testVersion2.VersionNumber);
Assert.AreEqual(2, testVersion2.ArticleNumber);
//// Test Version 2 Logs
Assert.IsTrue(testVersion2.ArticleLogs.Any(a => a.IdentityUserId == _testUser.Id &&
a.ActivityNotes == "New version"));
Assert.AreEqual(1, testVersion2.ArticleLogs.Count);
// Test Version 3
Assert.IsFalse(testVersion3.Published.HasValue);
Assert.AreEqual(3, testVersion3.VersionNumber);
Assert.AreEqual(2, testVersion3.ArticleNumber);
// Test Version 3 Logs
Assert.IsTrue(testVersion3.ArticleLogs.Any(a => a.IdentityUserId == _testUser.Id &&
a.ActivityNotes.Contains("Redirect")));
Assert.IsTrue(testVersion3.ArticleLogs.Any(a => a.IdentityUserId == _testUser.Id &&
a.ActivityNotes == "New version"));
Assert.IsTrue(testVersion3.ArticleLogs.Any(a => a.IdentityUserId == _testUser.Id &&
a.ActivityNotes.Contains("Redirect")));
Assert.AreEqual(2, testVersion3.ArticleLogs.Count);
//var redirect = await _dbContext.ArticleRedirects.FirstOrDefaultAsync(
// f => f.ArticleId == testVersion3.Id
//);
//Assert.AreEqual(oldPath, redirect.OldUrlPath);
// Test version 4
// Title for all version
Assert.AreEqual(testVersion1.Title, testVersion4.Title);
Assert.IsFalse(testVersion4.Published.HasValue);
Assert.AreEqual(4, testVersion4.VersionNumber);
Assert.AreEqual(2, testVersion4.ArticleNumber);
Assert.IsTrue(testVersion4.ArticleLogs.Any());
Assert.IsTrue(testVersion4.ArticleLogs.Any());
Assert.IsTrue(testVersion4.ArticleLogs.Count > 0);
//
// There should be 4 versions
//
Assert.AreEqual(4, dbContext.Articles.Count(a => a.ArticleNumber == version1.Model.ArticleNumber));
}
[TestMethod]
public async Task E_SetStatus()
{
await using var dbContext = utils.GetApplicationDbContext();
var logic = utils.GetArticleEditLogic(dbContext);
//
// Get the expected entity
//
var entity = await dbContext.Articles.FirstOrDefaultAsync(f => f.Title.Contains("New Version"));
//
// Get the last article by path, unpublished
//
var article = await logic.GetByUrl(entity.UrlPath, "en-US", false);
var expectedVersionCount = dbContext.Articles.Count(a => a.ArticleNumber == article.ArticleNumber);
//
// This should delete the article
//
var results1 = await logic.SetStatus(article.ArticleNumber, StatusCodeEnum.Deleted,
_testUser.Id);
//
// The result count should match the version count.
//
Assert.IsTrue(expectedVersionCount <= results1);
//
// Since this is deleted, this should not be able to be retrieved through any of these options.
//
var t = await logic.GetByUrl(entity.UrlPath);
Assert.IsNull(t);
Assert.IsNull(await logic.GetByUrl(entity.UrlPath, "en-US", false));
Assert.IsNull(await logic.GetByUrl(entity.UrlPath, "en-US", false,
false)); // The article is deleted, can't even retrieve it here
// Now set to inactive, this article should now be found.
Assert.IsNull(await logic.GetByUrl(entity.UrlPath));
Assert.IsNull(await logic.GetByUrl(entity.UrlPath, "en-US", false));
// The article is deleted, can't even retrieve it here
Assert.IsNull(await logic.GetByUrl(entity.UrlPath, "en-US", false,
false));
//
// Now "un-delete" this article.
//
await logic.SetStatus(article.ArticleNumber, StatusCodeEnum.Inactive,
_testUser.Id);
}
[TestMethod]
public async Task F_CheckTitle()
{
await using var dbContext = utils.GetApplicationDbContext();
var logic = utils.GetArticleEditLogic(dbContext);
var entity = await dbContext.Articles.FirstOrDefaultAsync(f => f.ArticleNumber == 1);
var article = await logic.GetByUrl(entity.UrlPath, "en-US", false, false);
Assert.IsFalse(await logic.ValidateTitle(entity.Title, 0));
Assert.IsTrue(await logic.ValidateTitle(article.Title, article.ArticleNumber));
}
[TestMethod]
public async Task G_FindByUrlTest()
{
await using var dbContext = utils.GetApplicationDbContext();
var logic = utils.GetArticleEditLogic(dbContext);
// Create test page 0
var article = await logic.Create("Public Safety Power Shutoff (PSPS)" + Guid.NewGuid());
article.ArticleNumber = 0;
article.Published = DateTime.Now.ToUniversalTime().AddDays(-1);
article.Content = "Hello world!";
var saved = await logic.UpdateOrInsert(article, _testUser.Id);
var prefix = Guid.NewGuid().ToString();
// Create test page 1
var article1 = await logic.Create(prefix);
article1.ArticleNumber = 0;
article1.Published = DateTime.Now.ToUniversalTime().AddDays(-1);
article1.Content = "Hello world!";
var saved1 = await logic.UpdateOrInsert(article1, _testUser.Id);
// Create test page 2
var article2 = await logic.Create(prefix + "/Angular");
article2.HeadJavaScript = "<meta name='ccms:framework' value='angular'>";
article2.ArticleNumber = 0;
article2.Published = DateTime.Now.ToUniversalTime().AddDays(-1);
article2.Content = "Hello world!";
var saved2 = await logic.UpdateOrInsert(article2, _testUser.Id);
// Create test page 3
var article3 = await logic.Create(prefix + "/Angular/Wow");
article3.HeadJavaScript = "<meta name='ccms:framework' value='angular'>";
article3.ArticleNumber = 0;
article3.Published = DateTime.Now.ToUniversalTime().AddDays(-1);
article3.Content = "Hello world!";
var saved3 = await logic.UpdateOrInsert(article3, _testUser.Id);
// Create test page 4
var article4 = await logic.Create(prefix + "/Angular/Wow/We");
article4.HeadJavaScript = "<meta name='ccms:framework' value='angular'><base href='/' />";
article4.ArticleNumber = 0;
article4.Published = DateTime.Now.ToUniversalTime().AddDays(-1);
article4.Content = "Hello world!";
var saved4 = await logic.UpdateOrInsert(article4, _testUser.Id);
var find = await logic.GetByUrl(saved.Model.UrlPath);
Assert.IsNotNull(find);
var find1 = await logic.GetByUrl(saved1.Model.UrlPath);
Assert.IsNotNull(find1);
var find1b = await logic.GetByUrl(saved1.Model.UrlPath + "/");
Assert.IsNotNull(find1b);
var find2 = await logic.GetByUrl(saved4.Model.UrlPath);
Assert.IsNotNull(find2);
Assert.IsTrue(find2.HeadJavaScript.Contains("ccms:framework", StringComparison.CurrentCultureIgnoreCase));
Assert.IsTrue(find2.HeadJavaScript.Contains("base", StringComparison.CurrentCultureIgnoreCase));
var find2b = await logic.GetByUrl(saved2.Model.UrlPath + "/");
Assert.IsNotNull(find2);
var find3 = await logic.GetByUrl(saved3.Model.UrlPath);
Assert.IsNotNull(find3);
var find3b = await logic.GetByUrl(saved3.Model.UrlPath + "/");
Assert.IsNotNull(find3b);
var find4 = await logic.GetByUrl(saved4.Model.UrlPath);
Assert.IsNotNull(find4);
var find4b = await logic.GetByUrl(saved4.Model.UrlPath + "/");
Assert.IsNotNull(find4b);
}
[TestMethod]
public async Task H_Test_ScheduledPublishing()
{
await using var dbContext = utils.GetApplicationDbContext();
var logic = utils.GetArticleEditLogic(dbContext);
//
// Get the home page that the public now sees
//
var originalArticle = await logic.GetByUrl("");
var articleNumber = originalArticle.ArticleNumber;
//
// Now validate by retrieving the same via Entity Framework
//
var mostRecentPublishedArticle = await dbContext.Articles
.Where(p => p.Published != null && p.ArticleNumber == articleNumber)
.OrderByDescending(o => o.VersionNumber).FirstOrDefaultAsync();
//
// The logic should have returned the current "live" article
//
Assert.AreEqual(mostRecentPublishedArticle.ArticleNumber, originalArticle.ArticleNumber);
Assert.AreEqual(mostRecentPublishedArticle.VersionNumber,
originalArticle.VersionNumber); // VERSION 4 is NOT PUBLISHED!! .
var versionNumber = originalArticle.VersionNumber;
//
// Now get the very last version
//
var lastArticleVersion = await logic.GetByUrl("", "en-US", false);
//
// It should not yet be published
//
Assert.IsNull(lastArticleVersion.Published);
//
// The article number should still match
//
Assert.AreEqual(articleNumber, lastArticleVersion.ArticleNumber);
//
// But the version number should not.
//
Assert.AreNotEqual(versionNumber, lastArticleVersion.VersionNumber);
// Update the last version, publish for 20 seconds from now...
lastArticleVersion.Published = DateTime.UtcNow.AddSeconds(20);
var newArticleViewModel = await logic.UpdateOrInsert(lastArticleVersion, _testUser.Id);
//
// We should still be getting the original article.
//
var currentArticle = await logic.GetByUrl("");
Assert.AreEqual(originalArticle.Id, currentArticle.Id);
//
// Wait 25 seconds for the new article to become published...
//
Thread.Sleep(25000);
//
// Now get the article, with same URL, this should be different.
//
var publishedArticle = await logic.GetByUrl("");
//
// This should be the NEW article ID.
Assert.AreEqual(newArticleViewModel.Model.Id, publishedArticle.Id);
}
//[TestMethod]
//public async Task I_Get_Translations_Home_Page()
//{
// await using var dbContext = utils.GetApplicationDbContext();
// var logic = utils.GetArticleEditLogic(dbContext);
// //var article = await _dbContext.Articles.FirstOrDefaultAsync(w => w.UrlPath == "ROOT");
// var article = await logic.Create("Rosetta Stone");
// article.Content =
// "The other night 'bout two o'clock, or maybe it was three,\r\nAn elephant with shining tusks came chasing after me.\r\nHis trunk was wavin' in the air an' spoutin' jets of steam\r\nAn' he was out to eat me up, but still I didn't scream\r\nOr let him see that I was scared - a better thought I had,\r\nI just escaped from where I was and crawled in bed with dad.\r\n\r\nSource: https://www.familyfriendpoems.com/poem/being-brave-at-night-by-edgar-albert-guest";
// article.Published = DateTime.Now.ToUniversalTime().AddDays(-1);
// var result = await logic.UpdateOrInsert(article, _testUser.Id);
// //
// // All four should find the home page.
// //
// //var test1 = await logic.GetByUrl(result.UrlPath, "en");
// //var test2 = await logic.GetByUrl(result.UrlPath, "es");
// var test3 = await logic.GetByUrl(result.Model.UrlPath, "vi");
// //var test4 = await logic.GetByUrl(result.UrlPath, "fr");
// //Assert.IsNotNull(test1);
// //Assert.IsNotNull(test2);
// Assert.IsNotNull(test3);
// //Assert.IsNotNull(test4);
// //Assert.AreEqual(test1.Id, test2.Id);
// Assert.AreEqual(result.Model.Id, test3.Id);
// Assert.AreEqual("đá Rosetta", test3.Title);
// //Assert.AreEqual(test1.Id, test4.Id);
//}
}
} | 44.040783 | 479 | 0.597289 | [
"Apache-2.0"
] | CosmosSoftware/Cosmos.Cms | Cosmos.Tests/CORE_F01_ArticleEditLogicTests.cs | 27,001 | C# |
/*
Copyright 2012-2019 Marco De Salvo
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using RDFSharp.Model;
namespace RDFSharp.Query
{
/// <summary>
/// RDFAvgAggregator represents an AVG aggregation function applied by a GroupBy modifier
/// </summary>
public class RDFAvgAggregator: RDFAggregator
{
#region Ctors
/// <summary>
/// Default-ctor to build an AVG aggregator on the given variable and with the given projection name
/// </summary>
public RDFAvgAggregator(RDFVariable aggrVariable, RDFVariable projVariable) : base(aggrVariable, projVariable) { }
#endregion
#region Interfaces
/// <summary>
/// Gets the string representation of the AVG aggregator
/// </summary>
public override String ToString()
{
return (this.IsDistinct ? String.Format("(AVG(DISTINCT {0}) AS {1})", this.AggregatorVariable, this.ProjectionVariable)
: String.Format("(AVG({0}) AS {1})", this.AggregatorVariable, this.ProjectionVariable));
}
#endregion
#region Methods
/// <summary>
/// Executes the partition on the given tablerow
/// </summary>
internal override void ExecutePartition(String partitionKey, DataRow tableRow)
{
//Get row value
Double rowValue = GetRowValueAsNumber(tableRow);
if (this.IsDistinct)
{
//Cache-Hit: distinctness failed
if (this.AggregatorContext.CheckPartitionKeyRowValueCache<Double>(partitionKey, rowValue))
return;
//Cache-Miss: distinctness passed
else
this.AggregatorContext.UpdatePartitionKeyRowValueCache<Double>(partitionKey, rowValue);
}
//Get aggregator value
Double aggregatorValue = this.AggregatorContext.GetPartitionKeyExecutionResult<Double>(partitionKey, 0d);
//In case of non-numeric values, consider partitioning failed
Double newAggregatorValue = Double.NaN;
if (!aggregatorValue.Equals(Double.NaN) && !rowValue.Equals(Double.NaN))
newAggregatorValue = rowValue + aggregatorValue;
//Update aggregator context (sum, count)
this.AggregatorContext.UpdatePartitionKeyExecutionResult<Double>(partitionKey, newAggregatorValue);
this.AggregatorContext.UpdatePartitionKeyExecutionCounter(partitionKey);
}
/// <summary>
/// Executes the projection producing result's table
/// </summary>
internal override DataTable ExecuteProjection(List<RDFVariable> partitionVariables)
{
DataTable projFuncTable = new DataTable();
//Initialization
partitionVariables.ForEach(pv =>
RDFQueryEngine.AddColumn(projFuncTable, pv.VariableName));
RDFQueryEngine.AddColumn(projFuncTable, this.ProjectionVariable.VariableName);
//Finalization
foreach (String partitionKey in this.AggregatorContext.ExecutionRegistry.Keys)
{
//Get aggregator value
Double aggregatorValue = this.AggregatorContext.GetPartitionKeyExecutionResult<Double>(partitionKey, 0d);
//Get aggregator counter
Double aggregatorCounter = this.AggregatorContext.GetPartitionKeyExecutionCounter(partitionKey);
//In case of non-numeric values, consider partition failed
Double finalAggregatorValue = Double.NaN;
if (!aggregatorValue.Equals(Double.NaN))
finalAggregatorValue = aggregatorValue / aggregatorCounter;
//Update aggregator context (sum, count)
this.AggregatorContext.UpdatePartitionKeyExecutionResult<Double>(partitionKey, finalAggregatorValue);
//Update result's table
this.UpdateProjectionTable(partitionKey, projFuncTable);
}
return projFuncTable;
}
/// <summary>
/// Helps in finalization step by updating the projection's result table
/// </summary>
internal override void UpdateProjectionTable(String partitionKey, DataTable projFuncTable)
{
//Get bindings from context
Dictionary<String, String> bindings = new Dictionary<String, String>();
foreach (String pkValue in partitionKey.Split(new String[] { "§PK§" }, StringSplitOptions.RemoveEmptyEntries))
{
String[] pValues = pkValue.Split(new String[] { "§PV§" }, StringSplitOptions.None);
bindings.Add(pValues[0], pValues[1]);
}
//Add aggregator value to bindings
Double aggregatorValue = this.AggregatorContext.GetPartitionKeyExecutionResult<Double>(partitionKey, 0d);
if (aggregatorValue.Equals(Double.NaN))
bindings.Add(this.ProjectionVariable.VariableName, String.Empty);
else
bindings.Add(this.ProjectionVariable.VariableName, new RDFTypedLiteral(Convert.ToString(aggregatorValue, CultureInfo.InvariantCulture), RDFModelEnums.RDFDatatypes.XSD_DOUBLE).ToString());
//Add bindings to result's table
RDFQueryEngine.AddRow(projFuncTable, bindings);
}
#endregion
}
} | 44.160584 | 203 | 0.647769 | [
"Apache-2.0"
] | Philippe-Laval/RDFSharp | RDFSharp/Query/Mirella/Algebra/Aggregators/RDFAvgAggregator.cs | 6,056 | C# |
//--------------------------------------------------
// <copyright file="ManagerDictionary.cs" company="Magenic">
// Copyright 2019 Magenic, All rights Reserved
// </copyright>
// <summary>Dictionary for handling driver managers</summary>
//--------------------------------------------------
using System;
using System.Collections.Generic;
namespace Magenic.Maqs.BaseTest
{
/// <summary>
/// Driver manager dictionary
/// </summary>
public class ManagerDictionary : Dictionary<string, DriverManager>, IDisposable
{
/// <summary>
/// Get the driver for the associated driver manager
/// </summary>
/// <typeparam name="T">Type of driver</typeparam>
/// <param name="key">Key for the manager</param>
/// <returns>The managed driver</returns>
public T GetDriver<T>(string key)
{
return (T)this[key].Get();
}
/// <summary>
/// Get a driver
/// </summary>
/// <typeparam name="T">The type of driver</typeparam>
/// <typeparam name="U">The type of driver manager</typeparam>
/// <returns>The driver</returns>
public T GetDriver<T, U>() where U : DriverManager
{
return (T)this[typeof(U).FullName].Get();
}
/// <summary>
/// Add a manager
/// </summary>
/// <param name="manager">The manager</param>
public void Add(DriverManager manager)
{
this.Add(manager.GetType().FullName, manager);
}
/// <summary>
/// Add or replace a manager
/// </summary>
/// <param name="manager">The manager</param>
public void AddOrOverride(DriverManager manager)
{
this.AddOrOverride(manager.GetType().FullName, manager);
}
/// <summary>
/// Add or replace a manager
/// </summary>
/// <param name="key">Key for storing the manager</param>
/// <param name="manager">The manager</param>
public void AddOrOverride(string key, DriverManager manager)
{
this.Remove(key);
this.Add(key, manager);
}
/// <summary>
/// Remove a driver manager
/// </summary>
/// <param name="key">Key for the manager you want removed</param>
/// <returns>True if the manager was removed</returns>
public new bool Remove(string key)
{
if (this.ContainsKey(key))
{
this[key].Dispose();
}
return base.Remove(key);
}
/// <summary>
/// Remove a driver manager
/// </summary>
/// <param name="type">The type of manager</param>
/// <returns>True if the manager was removed</returns>
public bool Remove(Type type)
{
string key = type.FullName;
if (this.ContainsKey(key))
{
this[key].Dispose();
}
return base.Remove(key);
}
/// <summary>
/// Clear the dictionary
/// </summary>
public new void Clear()
{
foreach (KeyValuePair<string, DriverManager> driver in this)
{
driver.Value.Dispose();
}
base.Clear();
}
/// <summary>
/// Dispose the class
/// </summary>
public void Dispose()
{
this.Clear();
}
}
} | 29.041322 | 83 | 0.501423 | [
"MIT"
] | skalpin/MAQS | Framework/BaseTest/ManagerDictionary.cs | 3,516 | C# |
using Godot;
using System;
public class Rifile : Weapon
{
public override void _Ready()
{
base._Ready();
}
protected override void FireEffect()
{
AnimationPlayer animationPlayer = (AnimationPlayer)GetNode("AnimationPlayer");
animationPlayer.Play("MuzzleFlash");
}
}
| 19.058824 | 90 | 0.635802 | [
"MIT"
] | brendanmoyer/topdown-2d-multiplayer | weapons/Rifile.cs | 324 | C# |
using System;
using System.Web;
using System.Web.Mvc;
using Elmah;
using GeoGrafija.CustomFilters;
namespace GeoGrafija.Areas.Admin.Controllers
{
[Authorize]
[RolesActionFilter(RequiredRoles = "Admin")]
[RoleOrganizer]
public class ElmahController : Controller
{
public ActionResult Index()
{
return new ElmahResult();
}
public ActionResult Stylesheet()
{
return new ElmahResult("stylesheet");
}
public ActionResult Rss()
{
return new ElmahResult("rss");
}
public ActionResult DigestRss()
{
return new ElmahResult("digestrss");
}
public ActionResult About()
{
return new ElmahResult("about");
}
public ActionResult Detail()
{
return new ElmahResult("detail");
}
public ActionResult Download()
{
return new ElmahResult("download");
}
public ActionResult Json()
{
return new ElmahResult("json");
}
public ActionResult Xml()
{
return new ElmahResult("xml");
}
}
internal class ElmahResult : ActionResult
{
private readonly string _resouceType;
public ElmahResult()
: this(null)
{
}
public ElmahResult(string resouceType)
{
_resouceType = resouceType;
}
public override void ExecuteResult(ControllerContext context)
{
var factory = new ErrorLogPageFactory();
if (!string.IsNullOrEmpty(_resouceType))
{
string pathInfo = "/" + _resouceType;
context.HttpContext.RewritePath(FilePath(context), pathInfo,
context.HttpContext.Request.QueryString.ToString());
}
var currentContext = GetCurrentContextAsHttpContext(context);
var httpHandler = factory.GetHandler(currentContext, null, null, null);
var httpAsyncHandler = httpHandler as IHttpAsyncHandler;
if (httpAsyncHandler != null)
{
httpAsyncHandler.BeginProcessRequest(currentContext, r => { }, null);
return;
}
httpHandler.ProcessRequest(currentContext);
}
private static HttpContext GetCurrentContextAsHttpContext(ControllerContext context)
{
return context.HttpContext.ApplicationInstance.Context;
}
private string FilePath(ControllerContext context)
{
return _resouceType != "stylesheet"
? context.HttpContext.Request.Path.Replace(String.Format("/{0}", _resouceType), string.Empty)
: context.HttpContext.Request.Path;
}
}
}
| 26.053571 | 116 | 0.559287 | [
"MIT"
] | emir01/GeoGrafija | GeoGrafija/GeoGrafija/Areas/Admin/Controllers/ElmahController.cs | 2,918 | C# |
namespace BlogMind.Controllers.Resources
{
public class LikeResource
{
public int CommentId { get; set; }
public string AppUserId { get; set; }
}
}
| 19.666667 | 45 | 0.627119 | [
"MIT"
] | nesta-bg/BlogMind | BlogMind/Controllers/Resources/LikeResource.cs | 179 | C# |
//
// This code was generated by a tool. Any changes made manually will be lost
// the next time this code is regenerated.
//
using System.Reflection;
[assembly: AssemblyVersion("0.1.0622.1717")]
[assembly: AssemblyFileVersion("0.1.0622.1717")]
[assembly: AssemblyInformationalVersion("0.1.0622.1717")]
| 28 | 76 | 0.74026 | [
"MIT"
] | dend/grunt | Grunt/Grunt/VersioningTemplate.cs | 310 | C# |
using System.Text.Json.Serialization;
namespace Frank.Libraries.Internet.Wikipedia.Models.Related
{
public class Mobile
{
[JsonPropertyName("page")]
public string Page { get; set; }
[JsonPropertyName("revisions")]
public string Revisions { get; set; }
[JsonPropertyName("edit")]
public string Edit { get; set; }
[JsonPropertyName("talk")]
public string Talk { get; set; }
}
} | 23.947368 | 59 | 0.615385 | [
"MIT"
] | frankhaugen/Frank.Libraries | src/Frank.Libraries.Internet/Wikipedia/Models/Related/Mobile.cs | 455 | C# |
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using StackExchange.Redis;
namespace Redis.Net {
/// <summary>
/// Redis HashSet Warpper
/// </summary>
public class ReadOnlyRedisHashSet : AbstracRedisKey, IReadOnlyDictionary<RedisValue, RedisValue> {
public ReadOnlyRedisHashSet (IDatabase database, string setKey) : base (database, setKey, RedisType.Hash) { }
/// <summary>Determines whether the read-only dictionary contains an element that has the specified key.</summary>
/// <param name="key">The key to locate.</param>
/// <returns>true if the read-only dictionary contains an element that has the specified key; otherwise, false.</returns>
/// <exception cref="T:System.ArgumentNullException"><paramref name="key">key</paramref> is null.</exception>
public bool ContainsKey (RedisValue key) {
return Database.HashExists (SetKey, key);
}
/// <summary>Gets the value that is associated with the specified key.</summary>
/// <param name="key">The key to locate.</param>
/// <param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the value parameter. This parameter is passed uninitialized.</param>
/// <returns>true if the object that implements the <see cref="T:System.Collections.Generic.IReadOnlyDictionary`2"></see> interface contains an element that has the specified key; otherwise, false.</returns>
/// <exception cref="T:System.ArgumentNullException"><paramref name="key">key</paramref> is null.</exception>
public bool TryGetValue (RedisValue key, out RedisValue value) {
var result = Database.HashGet (SetKey, key);
value = result;
return result.HasValue;
}
public RedisValue GetValue (RedisValue hashField) {
return Database.HashGet (SetKey, hashField);
}
public RedisValue[] GetValues (params RedisValue[] hashField) {
return Database.HashGet (SetKey, hashField);
}
/// <summary>Gets the element that has the specified key in the read-only dictionary.</summary>
/// <param name="key">The key to locate.</param>
/// <returns>The element that has the specified key in the read-only dictionary.</returns>
/// <exception cref="T:System.ArgumentNullException"><paramref name="key">key</paramref> is null.</exception>
/// <exception cref="T:System.Collections.Generic.KeyNotFoundException">The property is retrieved and <paramref name="key">key</paramref> is not found.</exception>
public RedisValue this [RedisValue key] {
get {
if (TryGetValue (key, out var value)) {
return value;
}
return RedisValue.Null;
}
set => Database.HashSet (SetKey, key, value);
}
public IEnumerable<RedisValue> Keys => Database.HashKeys (SetKey);
/// <summary>Gets an <see cref="T:System.Collections.Generic.ICollection`1"></see> containing the keys of the <see cref="T:System.Collections.Generic.IDictionary`2"></see>.</summary>
/// <returns>An <see cref="T:System.Collections.Generic.ICollection`1"></see> containing the keys of the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"></see>.</returns>
public IEnumerable<RedisValue> Values => Database.HashValues (SetKey);
///<summary>
/// 当前集合数量
///</summary>
public int Count => (int) Database.HashLength (SetKey);
public long LongCount => Database.HashLength (SetKey);
public IEnumerable<HashEntry> Scan (RedisValue pattern = default, int pageSize = 10, long cursor = 0, int pageOffset = 0) {
return Database.HashScan (SetKey, pattern, pageSize, cursor, pageOffset);
}
#region Async Methods
/// <summary>Determines whether the read-only dictionary contains an element that has the specified key.</summary>
/// <param name="key">The key to locate.</param>
/// <returns>true if the read-only dictionary contains an element that has the specified key; otherwise, false.</returns>
/// <exception cref="T:System.ArgumentNullException"><paramref name="key">key</paramref> is null.</exception>
public async Task<bool> ContainsKeyAsync (RedisValue key) {
return await Database.HashExistsAsync (SetKey, key);
}
public async Task<RedisValue> GetValueAsync (RedisValue key) {
return await Database.HashGetAsync (SetKey, key);
}
public async Task<RedisValue[]> GetValuesAsync (params RedisValue[] keys) {
return await Database.HashGetAsync (SetKey, keys);
}
public async Task<RedisValue[]> GetKeysAsync () {
return await Database.HashKeysAsync (SetKey);
}
///<summary>
/// 获取全部数值
///</summary>
public async Task<RedisValue[]> ValuesAsync () {
return await Database.HashValuesAsync (SetKey);
}
public async Task<long> CountAsync () {
return await Database.HashLengthAsync (SetKey);
}
/// <summary>
/// The HSCAN command is used to incrementally iterate over a hash; note: to resume an iteration via cursor, cast the original enumerable or enumerator to IScanningCursor.
/// </summary>
/// <param name="pattern">The pattern of keys to get entries for.</param>
/// <param name="pageSize">The page size to iterate by.</param>
/// <param name="cursor">The cursor position to start at.</param>
/// <param name="pageOffset">The page offset to start at.</param>
/// <param name="flags">The flags to use for this operation.</param>
/// <returns></returns>
public IEnumerable<HashEntry> Scan (RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) {
return Database.HashScan (SetKey, pattern, pageSize, cursor, pageOffset, flags);
}
/// <summary>
/// The HSCAN command is used to incrementally iterate over a hash; note: to resume an iteration via cursor, cast the original enumerable or enumerator to IScanningCursor.
/// </summary>
/// <param name="pattern">The pattern of keys to get entries for.</param>
/// <param name="pageSize">The page size to iterate by.</param>
/// <param name="cursor">The cursor position to start at.</param>
/// <param name="pageOffset">The page offset to start at.</param>
/// <param name="flags">The flags to use for this operation.</param>
/// <returns></returns>
public IAsyncEnumerable<HashEntry> ScanAsync (RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) {
return Database.HashScanAsync (SetKey, pattern, pageSize, cursor, pageOffset, flags);
}
#endregion
#region Implementation of IEnumerable
/// <summary>Returns an enumerator that iterates through the collection.</summary>
/// <returns>An enumerator that can be used to iterate through the collection.</returns>
public IEnumerator<KeyValuePair<RedisValue, RedisValue>> GetEnumerator () {
var entities = Database.HashGetAll (SetKey);
foreach (var entry in entities) {
yield return new KeyValuePair<RedisValue, RedisValue> (entry.Name, entry.Value);
}
}
/// <summary>Returns an enumerator that iterates through a collection.</summary>
/// <returns>An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection.</returns>
IEnumerator IEnumerable.GetEnumerator () {
return GetEnumerator ();
}
#endregion
}
} | 52.947712 | 237 | 0.650784 | [
"MIT"
] | zwq00000/Redis.Net | src/Redis.Net/ReadOnlyRedisHashSet.cs | 8,127 | C# |
using AzureFromTheTrenches.Commanding.Abstractions;
namespace FunctionMonkey.Abstractions.Builders
{
/// <summary>
/// An interface that allows for the configuration of service bus triggered functions
/// </summary>
public interface IServiceBusFunctionBuilder
{
/// <summary>
/// Associate a function with the named service bus queue and command type
/// </summary>
/// <typeparam name="TCommand">The command type</typeparam>
/// <param name="queueName">The name of the queue</param>
/// <param name="isSessionEnabled">Should session IDs be used when processing the queue, requires a session ID enabled queue. Defaults to false.</param>
/// <returns>A service bus function builder that allows more functions to be created</returns>
IServiceBusFunctionOptionBuilder<TCommand> QueueFunction<TCommand>(string queueName, bool isSessionEnabled=false);
/// <summary>
/// Associate a function with the named topic and subscription and command type
/// </summary>
/// <typeparam name="TCommand">The type of the command</typeparam>
/// <param name="topicName">The name of the topic</param>
/// <param name="subscriptionName">The name of the subscription</param>
/// /// <param name="isSessionEnabled">Should session IDs be used when processing the queue, requires a session ID enabled subscription. Defaults to false.</param>
/// <returns>A service bus function builder that allows more functions to be created</returns>
IServiceBusFunctionOptionBuilder<TCommand> SubscriptionFunction<TCommand>(string topicName, string subscriptionName, bool isSessionEnabled=false);
}
}
| 57.533333 | 171 | 0.705098 | [
"MIT"
] | AKomyshan/FunctionMonkey | Source/FunctionMonkey.Abstractions/Builders/IServiceBusFunctionBuilder.cs | 1,728 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Tajima
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
}
| 21.956522 | 65 | 0.607921 | [
"MIT"
] | joalri24/Tajima | Tajima/Program.cs | 507 | C# |
using System;
using System.Threading.Tasks;
namespace Owin.Security.Providers.Buffer
{
/// <summary>
/// Default <see cref="IBufferAuthenticationProvider"/> implementation.
/// </summary>
public class BufferAuthenticationProvider : IBufferAuthenticationProvider
{
/// <summary>
/// Initializes a <see cref="BufferAuthenticationProvider"/>
/// </summary>
public BufferAuthenticationProvider()
{
OnAuthenticated = context => Task.FromResult<object>(null);
OnReturnEndpoint = context => Task.FromResult<object>(null);
}
/// <summary>
/// Gets or sets the function that is invoked when the Authenticated method is invoked.
/// </summary>
public Func<BufferAuthenticatedContext, Task> OnAuthenticated { get; set; }
/// <summary>
/// Gets or sets the function that is invoked when the ReturnEndpoint method is invoked.
/// </summary>
public Func<BufferReturnEndpointContext, Task> OnReturnEndpoint { get; set; }
/// <summary>
/// Invoked whenever Buffer succesfully authenticates a user
/// </summary>
/// <param name="context">Contains information about the login session as well as the user <see cref="System.Security.Claims.ClaimsIdentity"/>.</param>
/// <returns>A <see cref="Task"/> representing the completed operation.</returns>
public virtual Task Authenticated(BufferAuthenticatedContext context)
{
return OnAuthenticated(context);
}
/// <summary>
/// Invoked prior to the <see cref="System.Security.Claims.ClaimsIdentity"/> being saved in a local cookie and the browser being redirected to the originally requested URL.
/// </summary>
/// <param name="context"></param>
/// <returns>A <see cref="Task"/> representing the completed operation.</returns>
public virtual Task ReturnEndpoint(BufferReturnEndpointContext context)
{
return OnReturnEndpoint(context);
}
}
} | 41.74 | 180 | 0.644466 | [
"MIT"
] | gauravbhavsar/OwinOAuthProviders | Owin.Security.Providers/Buffer/Provider/BufferAuthenticationProvider.cs | 2,089 | C# |
using System;
using System.Globalization;
using Jint.Runtime;
namespace Jint.Native
{
public sealed class JsNumber : JsValue, IEquatable<JsNumber>
{
internal readonly double _value;
// how many decimals to check when determining if double is actually an int
private const double DoubleIsIntegerTolerance = double.Epsilon * 100;
private static readonly long NegativeZeroBits = BitConverter.DoubleToInt64Bits(-0.0);
// we can cache most common values, doubles are used in indexing too at times so we also cache
// integer values converted to doubles
private const int NumbersMax = 1024 * 10;
private static readonly JsNumber[] _doubleToJsValue = new JsNumber[NumbersMax];
private static readonly JsNumber[] _intToJsValue = new JsNumber[NumbersMax];
private static readonly JsNumber DoubleNaN = new JsNumber(double.NaN);
private static readonly JsNumber DoubleNegativeOne = new JsNumber((double) -1);
private static readonly JsNumber DoublePositiveInfinity = new JsNumber(double.PositiveInfinity);
private static readonly JsNumber DoubleNegativeInfinity = new JsNumber(double.NegativeInfinity);
private static readonly JsNumber IntegerNegativeOne = new JsNumber(-1);
static JsNumber()
{
for (int i = 0; i < NumbersMax; i++)
{
_intToJsValue[i] = new JsNumber(i);
_doubleToJsValue[i] = new JsNumber((double) i);
}
}
public JsNumber(double value) : base(Types.Number)
{
_value = value;
}
public JsNumber(int value) : base(Types.Number)
{
_value = value;
}
public JsNumber(uint value) : base(Types.Number)
{
_value = value;
}
public override object ToObject()
{
return _value;
}
internal static JsNumber Create(double value)
{
// we can cache positive double zero, but not negative, -0 == 0 in C# but in JS it's a different story
if ((value == 0 && BitConverter.DoubleToInt64Bits(value) != NegativeZeroBits || value >= 1)
&& value < _doubleToJsValue.Length
&& System.Math.Abs(value % 1) <= DoubleIsIntegerTolerance)
{
return _doubleToJsValue[(int) value];
}
if (value == -1)
{
return DoubleNegativeOne;
}
if (value == double.NegativeInfinity)
{
return DoubleNegativeInfinity;
}
if (value == double.PositiveInfinity)
{
return DoublePositiveInfinity;
}
if (double.IsNaN(value))
{
return DoubleNaN;
}
return new JsNumber(value);
}
internal static JsNumber Create(int value)
{
if ((uint) value < (uint) _intToJsValue.Length)
{
return _intToJsValue[value];
}
if (value == -1)
{
return IntegerNegativeOne;
}
return new JsNumber(value);
}
internal static JsNumber Create(uint value)
{
if (value < (uint) _intToJsValue.Length)
{
return _intToJsValue[value];
}
return new JsNumber(value);
}
internal static JsNumber Create(ulong value)
{
if (value < (ulong) _intToJsValue.Length)
{
return _intToJsValue[value];
}
return new JsNumber(value);
}
public override string ToString()
{
return _value.ToString(CultureInfo.InvariantCulture);
}
public override bool Equals(JsValue obj)
{
if (ReferenceEquals(null, obj))
{
return false;
}
if (!(obj is JsNumber number))
{
return false;
}
return Equals(number);
}
public bool Equals(JsNumber other)
{
if (ReferenceEquals(null, other))
{
return false;
}
if (ReferenceEquals(this, other))
{
return true;
}
return _value == other._value;
}
public override int GetHashCode()
{
return _value.GetHashCode();
}
}
} | 28.054545 | 114 | 0.530352 | [
"BSD-2-Clause"
] | AsyncVoid/jint | Jint/Native/JsNumber.cs | 4,631 | C# |
using BeatSaberMarkupLanguage;
using BeatSaberMarkupLanguage.Attributes;
using BeatSaberMarkupLanguage.Settings;
using System;
using Zenject;
namespace IntroSkip.UI
{
internal class SettingsHost : IInitializable, IDisposable
{
private readonly Config _config;
[UIValue("intro-skip-toggle")]
public bool IntroSkipToggle
{
get => _config.AllowIntroSkip;
set => _config.AllowIntroSkip = value;
}
[UIValue("outro-skip-toggle")]
public bool OutroSkipToggle
{
get => _config.AllowOutroSkip;
set => _config.AllowOutroSkip = value;
}
public SettingsHost(Config config)
{
_config = config;
}
public void Initialize()
{
BSMLSettings.instance.AddSettingsMenu("Intro Skip", "IntroSkip.UI.settings.bsml", this);
}
public void Dispose()
{
if (BSMLParser.IsSingletonAvailable && BSMLSettings.instance != null)
BSMLSettings.instance.RemoveSettingsMenu(this);
}
[UIAction("set-intro-skip-toggle")]
protected void SetIntro(bool value) => IntroSkipToggle = value;
[UIAction("set-outro-skip-toggle")]
protected void SetOutro(bool value) => OutroSkipToggle = value;
}
} | 27.44898 | 100 | 0.612639 | [
"MIT"
] | Auros/Intro-Skip | Intro Skip/UI/SettingsHost.cs | 1,347 | C# |
using System;
using UnityEngine;
namespace UnityAtoms
{
public class ConditionalGameActionHelper<T1, GA, C> where GA : GameAction<T1> where C : GameFunction<bool, T1>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
[SerializeField]
private GA ElseAction = null;
[SerializeField]
private VoidAction ElseVoidAction = null;
public void Do(T1 t1)
{
if (Condition == null || Condition.Call(t1))
{
if (Action != null) { Action.Do(t1); }
if (VoidAction != null) { VoidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
}
}
}
public class ConditionalGameActionHelper<T1, T2, GA, C> where GA : GameAction<T1, T2> where C : GameFunction<bool, T1, T2>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
[SerializeField]
private GA ElseAction = null;
[SerializeField]
private VoidAction ElseVoidAction = null;
public void Do(T1 t1, T2 t2)
{
if (Condition == null || Condition.Call(t1, t2))
{
if (Action != null) { Action.Do(t1, t2); }
if (VoidAction != null) { VoidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1, t2); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
}
}
}
public class ConditionalGameActionHelper<T1, T2, T3, GA, C> where GA : GameAction<T1, T2, T3> where C : GameFunction<bool, T1, T2, T3>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
[SerializeField]
private GA ElseAction = null;
[SerializeField]
private VoidAction ElseVoidAction = null;
public void Do(T1 t1, T2 t2, T3 t3)
{
if (Condition == null || Condition.Call(t1, t2, t3))
{
if (Action != null) { Action.Do(t1, t2, t3); }
if (VoidAction != null) { VoidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1, t2, t3); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
}
}
}
public class ConditionalGameActionHelper<T1, T2, T3, T4, GA, C> where GA : GameAction<T1, T2, T3, T4> where C : GameFunction<bool, T1, T2, T3, T4>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
[SerializeField]
private GA ElseAction = null;
[SerializeField]
private VoidAction ElseVoidAction = null;
public void Do(T1 t1, T2 t2, T3 t3, T4 t4)
{
if (Condition == null || Condition.Call(t1, t2, t3, t4))
{
if (Action != null) { Action.Do(t1, t2, t3, t4); }
if (VoidAction != null) { VoidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1, t2, t3, t4); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
}
}
}
public class ConditionalGameActionHelper<T1, T2, T3, T4, T5, GA, C> where GA : GameAction<T1, T2, T3, T4, T5> where C : GameFunction<bool, T1, T2, T3, T4, T5>
{
[SerializeField]
private C Condition = null;
[SerializeField]
private GA Action = null;
[SerializeField]
private VoidAction VoidAction = null;
[SerializeField]
private GA ElseAction = null;
[SerializeField]
private VoidAction ElseVoidAction = null;
public void Do(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
{
if (Condition == null || Condition.Call(t1, t2, t3, t4, t5))
{
if (Action != null) { Action.Do(t1, t2, t3, t4, t5); }
if (VoidAction != null) { VoidAction.Do(); }
}
else
{
if (ElseAction != null) { ElseAction.Do(t1, t2, t3, t4, t5); }
if (ElseVoidAction != null) { ElseVoidAction.Do(); }
}
}
}
}
| 31.807947 | 162 | 0.512388 | [
"MIT"
] | AKOM-Studio/unity-atoms | Source/Base/ConditionalGameActionHelper.cs | 4,803 | C# |
using System.Diagnostics.Contracts;
namespace LibroLib.Caching
{
[ContractClass(typeof(IDiskCacheContract))]
public interface IDiskCache
{
void ClearCacheDirectory(string localCacheDirectoryPath);
void DeleteCacheFile (string localCacheFileName);
void EnsureDirectoryPathExists(string localCacheFileName, bool isFilePath);
string GetFullFilePath(string localCachePath);
/// <summary>
/// Determines whether the specified file exists in the cache directory structure.
/// </summary>
/// <param name="localCachePath">Relative path to the file to be checked.</param>
/// <returns><c>true</c> if file exists; <c>false</c> otherwise</returns>
bool IsCached(string localCachePath);
byte[] Load(string localCachePath);
void Save(string localCachePath, byte[] data);
}
[ContractClassFor(typeof(IDiskCache))]
// ReSharper disable once InconsistentNaming
internal abstract class IDiskCacheContract : IDiskCache
{
void IDiskCache.ClearCacheDirectory(string localCacheDirectoryPath)
{
Contract.Requires(localCacheDirectoryPath != null);
}
void IDiskCache.DeleteCacheFile(string localCacheFileName)
{
Contract.Requires(localCacheFileName != null);
}
void IDiskCache.EnsureDirectoryPathExists(string localCacheFileName, bool isFilePath)
{
Contract.Requires(localCacheFileName != null);
}
string IDiskCache.GetFullFilePath(string localCachePath)
{
Contract.Requires(localCachePath != null);
Contract.Ensures(Contract.Result<string>() != null);
throw new System.NotImplementedException();
}
bool IDiskCache.IsCached(string localCachePath)
{
Contract.Requires(localCachePath != null);
throw new System.NotImplementedException();
}
byte[] IDiskCache.Load(string localCachePath)
{
Contract.Requires(localCachePath != null);
throw new System.NotImplementedException();
}
void IDiskCache.Save(string localCachePath, byte[] data)
{
Contract.Requires(localCachePath != null);
}
}
} | 35.313433 | 94 | 0.633136 | [
"MIT"
] | breki/librolib | LibroLib.Common/Caching/IDiskCache.cs | 2,366 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MVRegistry
{
public enum HKEY
{
ClassesRoot,
CurrentUser,
LocalMachine,
Users,
CurrentConfig
}
}
| 16.333333 | 34 | 0.612245 | [
"MIT"
] | SoheilMV/MVRegistry | MVRegistry/HKEY.cs | 296 | C# |
namespace Gu.Localization.Analyzers.Tests.GULOC06UseInterpolationTests
{
using Gu.Roslyn.Asserts;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.Diagnostics;
using NUnit.Framework;
public class CodeFix
{
private static readonly DiagnosticAnalyzer Analyzer = new LiteralAnalyzer();
private static readonly CodeFixProvider Fix = new MakeInterpolatedFix();
private static readonly ExpectedDiagnostic ExpectedDiagnostic = ExpectedDiagnostic.Create("GULOC06");
[Test]
public void Interpolated()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo
{
public Foo()
{
var translate = ""abc {1}"";
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo
{
public Foo()
{
var translate = $""abc {1}"";
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
[Test]
public void InterpolatedVerbatim()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo
{
public Foo()
{
var translate = @""abc {1}"";
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo
{
public Foo()
{
var translate = $@""abc {1}"";
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
}
}
| 21.60274 | 109 | 0.565631 | [
"MIT"
] | General-Fault/Gu.Localization | Gu.Localization.Analyzers.Tests/GULOC06UseInterpolationTests/CodeFix.cs | 1,577 | C# |
/********************************************************************
The Multiverse Platform is made available under the MIT License.
Copyright (c) 2012 The Multiverse Foundation
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify,
merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
OR OTHER DEALINGS IN THE SOFTWARE.
*********************************************************************/
using System.ComponentModel;
using Microsoft.MultiverseInterfaceStudio.FrameXml.Controls;
using System.Xml.Serialization;
using System.Collections.Generic;
using System.Drawing.Design;
namespace Microsoft.MultiverseInterfaceStudio.FrameXml.Serialization
{
/// Generated from Ui.xsd into two pieces and merged here.
/// Manually modified later - DO NOT REGENERATE
/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "3.5.20706.1")]
[System.SerializableAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true, Namespace = "http://www.multiverse.net/ui")]
[System.Xml.Serialization.XmlRootAttribute(Namespace = "http://www.multiverse.net/ui", IsNullable = false)]
public partial class AbsDimension
{
private int xField;
private int yField;
/// <remarks/>
[System.Xml.Serialization.XmlAttributeAttribute()]
public int x
{
get
{
return this.xField;
}
set
{
this.xField = value;
}
}
/// <remarks/>
[System.Xml.Serialization.XmlAttributeAttribute()]
public int y
{
get
{
return this.yField;
}
set
{
this.yField = value;
}
}
}
}
| 30.180723 | 110 | 0.712176 | [
"MIT"
] | AustralianDisabilityLimited/MultiversePlatform | tools/ClientInterfaceEditor/FrameXmlEditor/Serialization/AbsDimension.cs | 2,505 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Mvc;
using Nop.Core.Domain.News;
using Nop.Services.Events;
using Nop.Services.Localization;
using Nop.Services.Logging;
using Nop.Services.Messages;
using Nop.Services.News;
using Nop.Services.Security;
using Nop.Services.Seo;
using Nop.Services.Stores;
using Nop.Web.Areas.Admin.Factories;
using Nop.Web.Areas.Admin.Infrastructure.Mapper.Extensions;
using Nop.Web.Areas.Admin.Models.News;
using Nop.Web.Framework.Mvc;
using Nop.Web.Framework.Mvc.Filters;
namespace Nop.Web.Areas.Admin.Controllers
{
public partial class NewsController : BaseAdminController
{
#region Fields
private readonly ICustomerActivityService _customerActivityService;
private readonly IEventPublisher _eventPublisher;
private readonly ILocalizationService _localizationService;
private readonly INewsModelFactory _newsModelFactory;
private readonly INewsService _newsService;
private readonly INotificationService _notificationService;
private readonly IPermissionService _permissionService;
private readonly IStoreMappingService _storeMappingService;
private readonly IStoreService _storeService;
private readonly IUrlRecordService _urlRecordService;
#endregion
#region Ctor
public NewsController(ICustomerActivityService customerActivityService,
IEventPublisher eventPublisher,
ILocalizationService localizationService,
INewsModelFactory newsModelFactory,
INewsService newsService,
INotificationService notificationService,
IPermissionService permissionService,
IStoreMappingService storeMappingService,
IStoreService storeService,
IUrlRecordService urlRecordService)
{
_customerActivityService = customerActivityService;
_eventPublisher = eventPublisher;
_localizationService = localizationService;
_newsModelFactory = newsModelFactory;
_newsService = newsService;
_notificationService = notificationService;
_permissionService = permissionService;
_storeMappingService = storeMappingService;
_storeService = storeService;
_urlRecordService = urlRecordService;
}
#endregion
#region Utilities
protected virtual void SaveStoreMappings(NewsItem newsItem, NewsItemModel model)
{
newsItem.LimitedToStores = model.SelectedStoreIds.Any();
_newsService.UpdateNews(newsItem);
var existingStoreMappings = _storeMappingService.GetStoreMappings(newsItem);
var allStores = _storeService.GetAllStores();
foreach (var store in allStores)
{
if (model.SelectedStoreIds.Contains(store.Id))
{
//new store
if (existingStoreMappings.Count(sm => sm.StoreId == store.Id) == 0)
_storeMappingService.InsertStoreMapping(newsItem, store.Id);
}
else
{
//remove store
var storeMappingToDelete = existingStoreMappings.FirstOrDefault(sm => sm.StoreId == store.Id);
if (storeMappingToDelete != null)
_storeMappingService.DeleteStoreMapping(storeMappingToDelete);
}
}
}
#endregion
#region Methods
#region News items
public virtual IActionResult Index()
{
return RedirectToAction("NewsItems");
}
public virtual IActionResult NewsItems(int? filterByNewsItemId)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
//prepare model
var model = _newsModelFactory.PrepareNewsContentModel(new NewsContentModel(), filterByNewsItemId);
return View(model);
}
[HttpPost]
public virtual IActionResult List(NewsItemSearchModel searchModel)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedDataTablesJson();
//prepare model
var model = _newsModelFactory.PrepareNewsItemListModel(searchModel);
return Json(model);
}
public virtual IActionResult NewsItemCreate()
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
//prepare model
var model = _newsModelFactory.PrepareNewsItemModel(new NewsItemModel(), null);
return View(model);
}
[HttpPost, ParameterBasedOnFormName("save-continue", "continueEditing")]
public virtual IActionResult NewsItemCreate(NewsItemModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
if (ModelState.IsValid)
{
var newsItem = model.ToEntity<NewsItem>();
newsItem.CreatedOnUtc = DateTime.UtcNow;
_newsService.InsertNews(newsItem);
//activity log
_customerActivityService.InsertActivity("AddNewNews",
string.Format(_localizationService.GetResource("ActivityLog.AddNewNews"), newsItem.Id), newsItem);
//search engine name
var seName = _urlRecordService.ValidateSeName(newsItem, model.SeName, model.Title, true);
_urlRecordService.SaveSlug(newsItem, seName, newsItem.LanguageId);
//Stores
SaveStoreMappings(newsItem, model);
_notificationService.SuccessNotification(_localizationService.GetResource("Admin.ContentManagement.News.NewsItems.Added"));
if (!continueEditing)
return RedirectToAction("NewsItems");
return RedirectToAction("NewsItemEdit", new { id = newsItem.Id });
}
//prepare model
model = _newsModelFactory.PrepareNewsItemModel(model, null, true);
//if we got this far, something failed, redisplay form
return View(model);
}
public virtual IActionResult NewsItemEdit(int id)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
//try to get a news item with the specified id
var newsItem = _newsService.GetNewsById(id);
if (newsItem == null)
return RedirectToAction("NewsItems");
//prepare model
var model = _newsModelFactory.PrepareNewsItemModel(null, newsItem);
return View(model);
}
[HttpPost, ParameterBasedOnFormName("save-continue", "continueEditing")]
public virtual IActionResult NewsItemEdit(NewsItemModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
//try to get a news item with the specified id
var newsItem = _newsService.GetNewsById(model.Id);
if (newsItem == null)
return RedirectToAction("NewsItems");
if (ModelState.IsValid)
{
newsItem = model.ToEntity(newsItem);
_newsService.UpdateNews(newsItem);
//activity log
_customerActivityService.InsertActivity("EditNews",
string.Format(_localizationService.GetResource("ActivityLog.EditNews"), newsItem.Id), newsItem);
//search engine name
var seName = _urlRecordService.ValidateSeName(newsItem, model.SeName, model.Title, true);
_urlRecordService.SaveSlug(newsItem, seName, newsItem.LanguageId);
//stores
SaveStoreMappings(newsItem, model);
_notificationService.SuccessNotification(_localizationService.GetResource("Admin.ContentManagement.News.NewsItems.Updated"));
if (!continueEditing)
return RedirectToAction("NewsItems");
return RedirectToAction("NewsItemEdit", new { id = newsItem.Id });
}
//prepare model
model = _newsModelFactory.PrepareNewsItemModel(model, newsItem, true);
//if we got this far, something failed, redisplay form
return View(model);
}
[HttpPost]
public virtual IActionResult Delete(int id)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
//try to get a news item with the specified id
var newsItem = _newsService.GetNewsById(id);
if (newsItem == null)
return RedirectToAction("NewsItems");
_newsService.DeleteNews(newsItem);
//activity log
_customerActivityService.InsertActivity("DeleteNews",
string.Format(_localizationService.GetResource("ActivityLog.DeleteNews"), newsItem.Id), newsItem);
_notificationService.SuccessNotification(_localizationService.GetResource("Admin.ContentManagement.News.NewsItems.Deleted"));
return RedirectToAction("NewsItems");
}
#endregion
#region Comments
public virtual IActionResult NewsComments(int? filterByNewsItemId)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
//try to get a news item with the specified id
var newsItem = _newsService.GetNewsById(filterByNewsItemId ?? 0);
if (newsItem == null && filterByNewsItemId.HasValue)
return RedirectToAction("NewsComments");
//prepare model
var model = _newsModelFactory.PrepareNewsCommentSearchModel(new NewsCommentSearchModel(), newsItem);
return View(model);
}
[HttpPost]
public virtual IActionResult Comments(NewsCommentSearchModel searchModel)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedDataTablesJson();
//prepare model
var model = _newsModelFactory.PrepareNewsCommentListModel(searchModel, searchModel.NewsItemId);
return Json(model);
}
[HttpPost]
public virtual IActionResult CommentUpdate(NewsCommentModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
//try to get a news comment with the specified id
var comment = _newsService.GetNewsCommentById(model.Id)
?? throw new ArgumentException("No comment found with the specified id");
var previousIsApproved = comment.IsApproved;
//fill entity from model
comment = model.ToEntity(comment);
_newsService.UpdateNewsComment(comment);
//activity log
_customerActivityService.InsertActivity("EditNewsComment",
string.Format(_localizationService.GetResource("ActivityLog.EditNewsComment"), comment.Id), comment);
//raise event (only if it wasn't approved before and is approved now)
if (!previousIsApproved && comment.IsApproved)
_eventPublisher.Publish(new NewsCommentApprovedEvent(comment));
return new NullJsonResult();
}
[HttpPost]
public virtual IActionResult CommentDelete(int id)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
//try to get a news comment with the specified id
var comment = _newsService.GetNewsCommentById(id)
?? throw new ArgumentException("No comment found with the specified id", nameof(id));
_newsService.DeleteNewsComment(comment);
//activity log
_customerActivityService.InsertActivity("DeleteNewsComment",
string.Format(_localizationService.GetResource("ActivityLog.DeleteNewsComment"), comment.Id), comment);
return new NullJsonResult();
}
[HttpPost]
public virtual IActionResult DeleteSelectedComments(ICollection<int> selectedIds)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
if (selectedIds == null)
return Json(new { Result = true });
var comments = _newsService.GetNewsCommentsByIds(selectedIds.ToArray());
_newsService.DeleteNewsComments(comments);
//activity log
foreach (var newsComment in comments)
{
_customerActivityService.InsertActivity("DeleteNewsComment",
string.Format(_localizationService.GetResource("ActivityLog.DeleteNewsComment"), newsComment.Id), newsComment);
}
return Json(new { Result = true });
}
[HttpPost]
public virtual IActionResult ApproveSelected(ICollection<int> selectedIds)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
if (selectedIds == null)
return Json(new { Result = true });
//filter not approved comments
var newsComments = _newsService.GetNewsCommentsByIds(selectedIds.ToArray()).Where(comment => !comment.IsApproved);
foreach (var newsComment in newsComments)
{
newsComment.IsApproved = true;
_newsService.UpdateNewsComment(newsComment);
//raise event
_eventPublisher.Publish(new NewsCommentApprovedEvent(newsComment));
//activity log
_customerActivityService.InsertActivity("EditNewsComment",
string.Format(_localizationService.GetResource("ActivityLog.EditNewsComment"), newsComment.Id), newsComment);
}
return Json(new { Result = true });
}
[HttpPost]
public virtual IActionResult DisapproveSelected(ICollection<int> selectedIds)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNews))
return AccessDeniedView();
if (selectedIds == null)
return Json(new { Result = true });
//filter approved comments
var newsComments = _newsService.GetNewsCommentsByIds(selectedIds.ToArray()).Where(comment => comment.IsApproved);
foreach (var newsComment in newsComments)
{
newsComment.IsApproved = false;
_newsService.UpdateNewsComment(newsComment);
//activity log
_customerActivityService.InsertActivity("EditNewsComment",
string.Format(_localizationService.GetResource("ActivityLog.EditNewsComment"), newsComment.Id), newsComment);
}
return Json(new { Result = true });
}
#endregion
#endregion
}
} | 37.776978 | 141 | 0.63188 | [
"MIT"
] | ASP-WAF/FireWall | Samples/NopeCommerce/Presentation/Nop.Web/Areas/Admin/Controllers/NewsController.cs | 15,755 | C# |
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using NSubstitute;
using NSubstitute.ExceptionExtensions;
using NUnit.Framework;
using SIL.Machine.WebApi.Services;
using SIL.Scripture;
using SIL.XForge.Configuration;
using SIL.XForge.DataAccess;
using SIL.XForge.Models;
using SIL.XForge.Realtime;
using SIL.XForge.Realtime.RichText;
using SIL.XForge.Scripture.Models;
using SIL.XForge.Scripture.Realtime;
using SIL.XForge.Services;
using SIL.XForge.Scripture.Services;
namespace PtdaSyncAll
{
// This class was copied from ParatextSyncRunnerTests.cs as a basis for writing more tests against PtdaSyncRunner.cs.
[TestFixture]
public class PtdaSyncRunnerTests
{
[Test]
public async Task SyncAsync_ProjectDoesNotExist()
{
var env = new TestEnvironment();
await env.Runner.RunAsync("project02", "user01", false);
}
[Test]
public async Task SyncAsync_UserDoesNotExist()
{
var env = new TestEnvironment();
env.SetupSFData(true, true, true);
await env.Runner.RunAsync("project01", "user02", false);
await env.ParatextService.DidNotReceive().GetBooksAsync(Arg.Any<UserSecret>(), "project01");
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.False);
}
[Test]
public async Task SyncAsync_Error()
{
var env = new TestEnvironment();
env.SetupSFData(true, true, false);
env.SetupPTData(new Book("MAT", 2), new Book("MRK", 2));
env.DeltaUsxMapper.When(d => d.ToChapterDeltas(Arg.Any<XDocument>())).Do(x => throw new Exception());
await env.Runner.RunAsync("project01", "user01", false);
env.FileSystemService.DidNotReceive().CreateFile(TestEnvironment.GetUsxFileName(TextType.Target, "MAT"));
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
// In stage1 migration we aren't calling this a failure, for CloneBookUsxAsync() to fail.
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_NewProjectTranslationSuggestionsAndCheckingDisabled()
{
var env = new TestEnvironment();
env.SetupSFData(false, false, false);
env.SetupPTData(new Book("MAT", 2), new Book("MRK", 2, false));
await env.Runner.RunAsync("project01", "user01", true);
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 1, TextType.Source), Is.False);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.False);
Assert.That(env.ContainsText("MRK", 1, TextType.Source), Is.False);
Assert.That(env.ContainsText("MRK", 2, TextType.Source), Is.False);
Assert.That(env.ContainsQuestion("MAT", 1), Is.False);
Assert.That(env.ContainsQuestion("MAT", 2), Is.False);
Assert.That(env.ContainsQuestion("MRK", 1), Is.False);
Assert.That(env.ContainsQuestion("MRK", 2), Is.False);
await env.EngineService.DidNotReceive().StartBuildByProjectIdAsync("project01");
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_NewProjectTranslationSuggestionsAndCheckingEnabled()
{
var env = new TestEnvironment();
env.SetupSFData(true, true, false);
env.SetupPTData(new Book("MAT", 2), new Book("MRK", 2, false));
await env.Runner.RunAsync("project01", "user01", true);
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 1, TextType.Source), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.True);
Assert.That(env.ContainsText("MRK", 1, TextType.Source), Is.False);
Assert.That(env.ContainsText("MRK", 2, TextType.Source), Is.False);
Assert.That(env.ContainsQuestion("MAT", 1), Is.False);
Assert.That(env.ContainsQuestion("MAT", 2), Is.False);
Assert.That(env.ContainsQuestion("MRK", 1), Is.False);
Assert.That(env.ContainsQuestion("MRK", 2), Is.False);
await env.EngineService.Received().StartBuildByProjectIdAsync("project01");
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_NewProjectOnlyTranslationSuggestionsEnabled()
{
var env = new TestEnvironment();
env.SetupSFData(true, false, false);
env.SetupPTData(new Book("MAT", 2), new Book("MRK", 2, false));
await env.Runner.RunAsync("project01", "user01", true);
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 1, TextType.Source), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.True);
Assert.That(env.ContainsText("MRK", 1, TextType.Source), Is.False);
Assert.That(env.ContainsText("MRK", 2, TextType.Source), Is.False);
Assert.That(env.ContainsQuestion("MAT", 1), Is.False);
Assert.That(env.ContainsQuestion("MAT", 2), Is.False);
Assert.That(env.ContainsQuestion("MRK", 1), Is.False);
Assert.That(env.ContainsQuestion("MRK", 2), Is.False);
await env.EngineService.Received().StartBuildByProjectIdAsync("project01");
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_NewProjectOnlyCheckingEnabled()
{
var env = new TestEnvironment();
env.SetupSFData(false, true, false);
env.SetupPTData(new Book("MAT", 2), new Book("MRK", 2, false));
await env.Runner.RunAsync("project01", "user01", true);
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 1, TextType.Source), Is.False);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.False);
Assert.That(env.ContainsText("MRK", 1, TextType.Source), Is.False);
Assert.That(env.ContainsText("MRK", 2, TextType.Source), Is.False);
Assert.That(env.ContainsQuestion("MAT", 1), Is.False);
Assert.That(env.ContainsQuestion("MAT", 2), Is.False);
Assert.That(env.ContainsQuestion("MRK", 1), Is.False);
Assert.That(env.ContainsQuestion("MRK", 2), Is.False);
await env.EngineService.DidNotReceive().StartBuildByProjectIdAsync("project01");
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_DataNotChanged()
{
var env = new TestEnvironment();
Book[] books = { new Book("MAT", 2), new Book("MRK", 2) };
env.SetupSFData(true, true, false, books);
env.SetupPTData(books);
await env.Runner.RunAsync("project01", "user01", false);
await env.ParatextService.DidNotReceive().UpdateBookTextAsync(Arg.Any<UserSecret>(), "target", "MAT",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.DidNotReceive().UpdateBookTextAsync(Arg.Any<UserSecret>(), "target", "MRK",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.DidNotReceive().UpdateBookTextAsync(Arg.Any<UserSecret>(), "source", "MAT",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.DidNotReceive().UpdateBookTextAsync(Arg.Any<UserSecret>(), "source", "MRK",
Arg.Any<string>(), Arg.Any<string>());
var delta = Delta.New().InsertText("text");
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 2, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 1, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 1, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 2, TextType.Source).DeepEquals(delta), Is.True);
await env.ParatextService.DidNotReceive().UpdateNotesAsync(Arg.Any<UserSecret>(), "target",
Arg.Any<string>());
SFProjectSecret projectSecret = env.GetProjectSecret();
Assert.That(projectSecret.SyncUsers.Count, Is.EqualTo(0));
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
Assert.That(project.UserRoles["user01"], Is.EqualTo(SFProjectRole.Administrator));
Assert.That(project.UserRoles["user02"], Is.EqualTo(SFProjectRole.Translator));
}
[Test]
public async Task SyncAsync_DataChangedTranslateAndCheckingEnabled()
{
var env = new TestEnvironment();
Book[] books = { new Book("MAT", 2), new Book("MRK", 2) };
env.SetupSFData(true, true, true, books);
env.SetupPTData(books);
await env.Runner.RunAsync("project01", "user01", false);
await env.ParatextService.Received().UpdateBookTextAsync(Arg.Any<UserSecret>(), "target", "MAT",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.Received().UpdateBookTextAsync(Arg.Any<UserSecret>(), "target", "MRK",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.DidNotReceive().UpdateBookTextAsync(Arg.Any<UserSecret>(), "source", "MAT",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.DidNotReceive().UpdateBookTextAsync(Arg.Any<UserSecret>(), "source", "MRK",
Arg.Any<string>(), Arg.Any<string>());
var delta = Delta.New().InsertText("text");
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 2, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 1, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 1, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 2, TextType.Source).DeepEquals(delta), Is.True);
await env.ParatextService.Received(2).UpdateNotesAsync(Arg.Any<UserSecret>(), "target", Arg.Any<string>());
SFProjectSecret projectSecret = env.GetProjectSecret();
Assert.That(projectSecret.SyncUsers.Count, Is.EqualTo(1));
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_DataChangedTranslateEnabledCheckingDisabled()
{
var env = new TestEnvironment();
Book[] books = { new Book("MAT", 2), new Book("MRK", 2) };
env.SetupSFData(true, false, true, books);
env.SetupPTData(books);
await env.Runner.RunAsync("project01", "user01", false);
await env.ParatextService.Received().UpdateBookTextAsync(Arg.Any<UserSecret>(), "target", "MAT",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.Received().UpdateBookTextAsync(Arg.Any<UserSecret>(), "target", "MRK",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.DidNotReceive().UpdateBookTextAsync(Arg.Any<UserSecret>(), "source", "MAT",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.DidNotReceive().UpdateBookTextAsync(Arg.Any<UserSecret>(), "source", "MRK",
Arg.Any<string>(), Arg.Any<string>());
await env.ParatextService.DidNotReceive().UpdateNotesAsync(Arg.Any<UserSecret>(), "target",
Arg.Any<string>());
var delta = Delta.New().InsertText("text");
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 2, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 1, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 1, TextType.Source).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 2, TextType.Source).DeepEquals(delta), Is.True);
SFProjectSecret projectSecret = env.GetProjectSecret();
Assert.That(projectSecret.SyncUsers.Count, Is.EqualTo(1));
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_ChaptersChanged()
{
var env = new TestEnvironment();
env.SetupSFData(true, true, false, new Book("MAT", 2), new Book("MRK", 2));
env.SetupPTData(new Book("MAT", 3), new Book("MRK", 1));
await env.Runner.RunAsync("project01", "user01", false);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 2, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 3, TextType.Source), Is.True);
Assert.That(env.ContainsText("MRK", 2, TextType.Source), Is.False);
Assert.That(env.ContainsQuestion("MAT", 2), Is.True);
Assert.That(env.ContainsQuestion("MRK", 2), Is.False);
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_ChapterValidityChanged()
{
var env = new TestEnvironment();
env.SetupSFData(true, true, false, new Book("MAT", 2), new Book("MRK", 2) { InvalidChapters = { 1 } });
env.SetupPTData(new Book("MAT", 2) { InvalidChapters = { 2 } }, new Book("MRK", 2));
await env.Runner.RunAsync("project01", "user01", false);
SFProject project = env.GetProject();
Assert.That(project.Texts[0].Chapters[0].IsValid, Is.True);
Assert.That(project.Texts[0].Chapters[1].IsValid, Is.False);
Assert.That(project.Texts[1].Chapters[0].IsValid, Is.True);
Assert.That(project.Texts[1].Chapters[1].IsValid, Is.True);
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_BooksChanged()
{
var env = new TestEnvironment();
env.SetupSFData(true, true, false, new Book("MAT", 2), new Book("MRK", 2));
env.SetupPTData(new Book("MAT", 2), new Book("LUK", 2));
await env.Runner.RunAsync("project01", "user01", false);
Assert.That(env.ContainsText("MRK", 1, TextType.Target), Is.False);
Assert.That(env.ContainsText("MRK", 2, TextType.Target), Is.False);
Assert.That(env.ContainsText("LUK", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("LUK", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MRK", 1, TextType.Source), Is.False);
Assert.That(env.ContainsText("MRK", 2, TextType.Source), Is.False);
Assert.That(env.ContainsText("LUK", 1, TextType.Source), Is.True);
Assert.That(env.ContainsText("LUK", 2, TextType.Source), Is.True);
Assert.That(env.ContainsQuestion("MRK", 1), Is.False);
Assert.That(env.ContainsQuestion("MRK", 2), Is.False);
Assert.That(env.ContainsQuestion("MAT", 1), Is.True);
Assert.That(env.ContainsQuestion("MAT", 2), Is.True);
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_MissingUsxFile()
{
var env = new TestEnvironment();
Book[] books = { new Book("MAT", 2), new Book("MRK", 2) };
env.SetupSFData(false, true, true, books);
env.FileSystemService.FileExists(TestEnvironment.GetUsxFileName(TextType.Target, "MAT")).Returns(false);
env.FileSystemService.EnumerateFiles(TestEnvironment.GetProjectPath(TextType.Target))
.Returns(new[] { "MRK.xml" });
env.SetupPTData(books);
await env.Runner.RunAsync("project01", "user01", false);
var delta = Delta.New().InsertText("text");
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Target).DeepEquals(delta), Is.True);
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_UserRoleChangedAndUserRemoved()
{
var env = new TestEnvironment();
Book[] books = { new Book("MAT", 2), new Book("MRK", 2) };
env.SetupSFData(true, true, false, books);
env.SetupPTData(books);
var ptUserRoles = new Dictionary<string, string>
{
{ "pt01", SFProjectRole.Translator }
};
env.ParatextService.GetProjectRolesAsync(Arg.Any<UserSecret>(), "target")
.Returns(Task.FromResult<IReadOnlyDictionary<string, string>>(ptUserRoles));
await env.Runner.RunAsync("project01", "user01", false);
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
Assert.That(project.UserRoles["user01"], Is.EqualTo(SFProjectRole.Translator));
await env.SFProjectService.Received().RemoveUserAsync("user01", "project01", "user02");
}
[Test]
public async Task SyncAsync_CheckerWithPTAccountNotRemoved()
{
var env = new TestEnvironment();
Book[] books = { new Book("MAT", 2), new Book("MRK", 2) };
env.SetupSFData(true, true, false, books);
env.SetupPTData(books);
var ptUserRoles = new Dictionary<string, string>
{
{ "pt01", SFProjectRole.Administrator }
};
env.ParatextService.GetProjectRolesAsync(Arg.Any<UserSecret>(), "target")
.Returns(Task.FromResult<IReadOnlyDictionary<string, string>>(ptUserRoles));
await env.SetUserRole("user02", SFProjectRole.CommunityChecker);
SFProject project = env.GetProject();
Assert.That(project.UserRoles["user02"], Is.EqualTo(SFProjectRole.CommunityChecker));
await env.Runner.RunAsync("project01", "user01", false);
project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
await env.SFProjectService.DidNotReceiveWithAnyArgs().RemoveUserAsync("user01", "project01", "user02");
}
[Test]
public async Task SyncAsync_TextDocAlreadyExists()
{
var env = new TestEnvironment();
env.SetupSFData(false, false, false, new Book("MAT", 2), new Book("MRK", 2));
env.RealtimeService.GetRepository<TextData>()
.Add(new TextData(Delta.New().InsertText("old text"))
{
Id = TextData.GetTextDocId("project01", 42, 1, TextType.Target)
});
env.SetupPTData(new Book("MAT", 2), new Book("MRK", 2), new Book("LUK", 2));
await env.Runner.RunAsync("project01", "user01", false);
var delta = Delta.New().InsertText("text");
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("MRK", 2, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("LUK", 1, TextType.Target).DeepEquals(delta), Is.True);
Assert.That(env.GetText("LUK", 2, TextType.Target).DeepEquals(delta), Is.True);
SFProject project = env.GetProject();
Assert.That(project.Sync.QueuedCount, Is.EqualTo(0));
Assert.That(project.Sync.LastSyncSuccessful, Is.True);
}
[Test]
public async Task SyncAsync_DbMissingChapter()
{
// The project in the DB has a book, but a Source chapter is missing from that book.
var env = new TestEnvironment();
env.SetupSFData(true, true, false, new Book("MAT", 3, 3) { MissingSourceChapters = { 2 } });
env.SetupPTData(new Book("MAT", 3, true));
// DB should start with Target chapter 2 but without Source chapter 2.
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.False);
// SUT
await env.Runner.RunAsync("project01", "user01", false);
env.Logger.DidNotReceiveWithAnyArgs().LogError(Arg.Any<Exception>(), Arg.Any<string>(), Arg.Any<string>());
var chapterContent = Delta.New().InsertText("text");
// DB should contain Source chapter 2 now from Paratext.
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Target).DeepEquals(chapterContent), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Source).DeepEquals(chapterContent), Is.True);
}
[Test]
public async Task SyncBookUSxAsync_InvalidBookStateAndNoTextData_SkipSync()
{
var env = new TestEnvironment();
Book matBook = new Book("MAT", 3, 3)
{
MissingTargetChapters = { 1, 2, 3 },
MissingSourceChapters = { 1, 2, 3 }
};
env.SetupSFData(true, true, false, matBook);
env.SetupPTData(new Book("MAT", 3, true));
await env.Runner.InitAsync("project01", "user01");
// There are no Matthew text docs in the SF DB
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.False);
TextInfo matBookTextInfo = env.TextInfoFromBook(matBook);
var chaptersToInclude = new HashSet<int>(matBookTextInfo.Chapters.Select(c => c.Number));
matBookTextInfo.Chapters.Clear();
// TextInfo from project doc claims there are zero chapters, which means the SF DB is corrupt.
// It should (?) have had all the chapters listed, or perhaps just one chapter (if it thinks it is a
// book with no chapters), but not zero chapters.
Assert.That(matBookTextInfo.Chapters.Count, Is.EqualTo(0), "setup");
string matFilename = TestEnvironment.GetUsxFileName(TextType.Target, "MAT");
// SUT
Assert.That(await env.Runner.SyncBookUsxAsync(matBookTextInfo, TextType.Target, "project01",
matFilename, false, chaptersToInclude), Is.Null);
// Did not throw. Returned a null list of Chapter objects.
}
[Test]
public async Task SyncBookUsxAsync_InvalidBookStateAndHasTextData_Crash()
{
var env = new TestEnvironment();
Book matBook = new Book("MAT", 3, 3);
env.SetupSFData(true, true, false, matBook);
env.SetupPTData(new Book("MAT", 3, true));
await env.Runner.InitAsync("project01", "user01");
// There are Matthew text docs in the SF DB, even tho the project doc has no record of them.
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.True);
TextInfo matBookTextInfo = env.TextInfoFromBook(matBook);
var chaptersToInclude = new HashSet<int>(matBookTextInfo.Chapters.Select(c => c.Number));
matBookTextInfo.Chapters.Clear();
// TextInfo from project doc is corrupt and claims there are zero chapters.
Assert.That(matBookTextInfo.Chapters.Count, Is.EqualTo(0), "setup");
string matFilename = TestEnvironment.GetUsxFileName(TextType.Target, "MAT");
// SUT
string exceptionMessage = Assert.ThrowsAsync<Exception>(() =>
env.Runner.SyncBookUsxAsync(matBookTextInfo, TextType.Target, "project01", matFilename, false,
chaptersToInclude)).Message;
Assert.That(exceptionMessage, Does.Contain("invalid"));
}
[Test]
public async Task SyncAsync_ParatextMissingChapter()
{
// The project in Paratext has a book, but a chapter is missing from that book.
var env = new TestEnvironment();
env.SetupSFData(true, true, false, new Book("MAT", 3, true));
env.SetupPTData(new Book("MAT", 3, 3) { MissingTargetChapters = { 2 }, MissingSourceChapters = { 2 } });
var chapterContent = Delta.New().InsertText("text");
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 1, TextType.Source), Is.True);
// DB should start with a chapter 2.
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Target).DeepEquals(chapterContent), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Source).DeepEquals(chapterContent), Is.True);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 3, TextType.Source), Is.True);
// SUT
await env.Runner.RunAsync("project01", "user01", false);
env.Logger.DidNotReceiveWithAnyArgs().LogError(Arg.Any<Exception>(), Arg.Any<string>(), Arg.Any<string>());
// DB should now be missing chapter 2, but retain chapters 1 and 3.
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 1, TextType.Source), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.False);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 3, TextType.Source), Is.True);
}
[Test]
public async Task SyncAsync_DbAndParatextMissingChapter()
{
// The project has a book, but a Source chapter is missing from that book. Both in the DB and in Paratext.
var env = new TestEnvironment();
env.SetupSFData(true, true, false, new Book("MAT", 3, 3) { MissingSourceChapters = { 2 } });
env.SetupPTData(new Book("MAT", 3, 3) { MissingSourceChapters = { 2 } });
// DB should start without Source chapter 2.
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.False);
// SUT
await env.Runner.RunAsync("project01", "user01", false);
env.Logger.DidNotReceiveWithAnyArgs().LogError(Arg.Any<Exception>(), Arg.Any<string>(), Arg.Any<string>());
// DB should still be missing Source chapter 2.
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.False);
}
[Test]
public async Task SyncAsync_ParatextMissingAllChapters()
{
// The project in PT has a book, but no chapters.
var env = new TestEnvironment();
env.SetupSFData(true, true, false, new Book("MAT", 3, true));
env.SetupPTData(new Book("MAT", 0, true));
var chapterContent = Delta.New().InsertText("text");
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 1, TextType.Source), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Target).DeepEquals(chapterContent), Is.True);
Assert.That(env.GetText("MAT", 2, TextType.Source).DeepEquals(chapterContent), Is.True);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 3, TextType.Source), Is.True);
// SUT
await env.Runner.RunAsync("project01", "user01", false);
env.Logger.DidNotReceiveWithAnyArgs().LogError(Arg.Any<Exception>(), Arg.Any<string>(), Arg.Any<string>());
// DB should now be missing all chapters except for the first, implicit chapter.
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 1, TextType.Source), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 2, TextType.Source), Is.False);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 3, TextType.Source), Is.False);
}
[Test]
public async Task FetchTextDocsAsync_FetchesExistingChapters()
{
var env = new TestEnvironment();
var numberChapters = 3;
var book = new Book("MAT", numberChapters, true);
env.SetupSFData(true, true, false, book);
await env.Runner.InitAsync("project01", "user01");
// SUT
SortedList<int, IDocument<TextData>> targetFetch =
await env.Runner.FetchTextDocsAsync(env.TextInfoFromBook(book), TextType.Target);
SortedList<int, IDocument<TextData>> sourceFetch =
await env.Runner.FetchTextDocsAsync(env.TextInfoFromBook(book), TextType.Source);
env.Runner.CloseConnection();
// Fetched numberChapters chapters, none of which are missing their chapter content.
Assert.That(targetFetch.Count, Is.EqualTo(numberChapters));
Assert.That(sourceFetch.Count, Is.EqualTo(numberChapters));
Assert.That(targetFetch.Count(doc => doc.Value.Data == null), Is.EqualTo(0));
Assert.That(sourceFetch.Count(doc => doc.Value.Data == null), Is.EqualTo(0));
}
[Test]
public async Task FetchTextDocsAsync_MissingRequestedChapters()
{
// In production, the expected chapters list, used to specify
// what FetchTextDocsAsync() should fetch, comes from the
// SF DB project doc texts.chapters array. This array
// specifies what Target chapter text docs the SF DB should
// ave. Re-using the Target chapter list when fetching Source
// chapter text docs from the SF DB can lead to problems if
// FetchTextDocsAsync() does not omit ones that aren't
// actually in the DB.
var env = new TestEnvironment();
var highestChapter = 20;
var missingSourceChapters = new HashSet<int>() { 2, 3, 10, 12 };
var existingTargetChapters = Enumerable.Range(1, highestChapter);
var existingSourceChapters = Enumerable.Range(1, highestChapter).Except(missingSourceChapters);
Assert.That(existingSourceChapters.Count(),
Is.EqualTo(highestChapter - missingSourceChapters.Count()), "setup");
Assert.That(existingTargetChapters.Count(),
Is.GreaterThan(existingSourceChapters.Count()), "setup");
var book = new Book("MAT", highestChapter, true) { MissingSourceChapters = missingSourceChapters };
env.SetupSFData(true, true, false, book);
await env.Runner.InitAsync("project01", "user01");
// SUT
var targetFetch = await env.Runner.FetchTextDocsAsync(env.TextInfoFromBook(book), TextType.Target);
var sourceFetch = await env.Runner.FetchTextDocsAsync(env.TextInfoFromBook(book), TextType.Source);
env.Runner.CloseConnection();
// Fetched only non-missing chapters. None have null Data.
Assert.That(targetFetch.Keys.SequenceEqual(existingTargetChapters));
Assert.That(sourceFetch.Keys.SequenceEqual(existingSourceChapters));
Assert.That(targetFetch.Count(doc => doc.Value.Data == null), Is.EqualTo(0));
Assert.That(sourceFetch.Count(doc => doc.Value.Data == null), Is.EqualTo(0));
}
[Test]
public async Task ChangeDbToNewSnapshotAsync_Works()
{
var env = new TestEnvironment();
var numberChapters = 4;
// SF DB has chapter text docs for chapters 1 and 2 only.
var missingDbChapters = new HashSet<int>() { 3, 4 };
var book = new Book("MAT", numberChapters, true)
{
MissingTargetChapters = missingDbChapters,
MissingSourceChapters = missingDbChapters
};
env.SetupSFData(true, true, false, book);
await env.Runner.InitAsync("project01", "user01");
var textInfo = env.TextInfoFromBook(book);
var targetTextDocs = await env.Runner.FetchTextDocsAsync(textInfo, TextType.Target);
var insertTextDelta = Delta.New().InsertText("text");
var insertPtDelta = Delta.New().InsertText("pt");
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(insertTextDelta), Is.True);
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(insertPtDelta), Is.False);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 4, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 5, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 6, TextType.Target), Is.False);
// Paratext has chapters 1, 4 and 6, with text.
var chapterDeltas = new int[] { 1, 4, 6 }
.Select(c => new ChapterDelta(c, 10, false,
Delta.New().InsertText("pt")))
.ToDictionary(cd => cd.Number);
// SUT
await env.Runner.ChangeDbToNewSnapshotAsync(textInfo,
TextType.Target, null, targetTextDocs, chapterDeltas);
env.Runner.CloseConnection();
// SF DB should now have just text in chapters 1, 4 and 6, matching Paratext.
// Note that chapter 2 is now missing.
Assert.That(env.ContainsText("MAT", 1, TextType.Target), Is.True);
// Content change to Chapter 1.
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(insertTextDelta), Is.False);
Assert.That(env.GetText("MAT", 1, TextType.Target).DeepEquals(insertPtDelta), Is.True);
Assert.That(env.ContainsText("MAT", 2, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 3, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 4, TextType.Target), Is.True);
Assert.That(env.ContainsText("MAT", 5, TextType.Target), Is.False);
Assert.That(env.ContainsText("MAT", 6, TextType.Target), Is.True);
}
private class Book
{
public Book(string bookId, int highestChapter, bool hasSource = true)
: this(bookId, highestChapter, hasSource ? highestChapter : 0)
{
}
public Book(string bookId, int highestTargetChapter, int highestSourceChapter)
{
Id = bookId;
HighestTargetChapter = highestTargetChapter;
HighestSourceChapter = highestSourceChapter;
}
public string Id { get; }
public int HighestTargetChapter { get; }
public int HighestSourceChapter { get; }
public HashSet<int> InvalidChapters { get; } = new HashSet<int>();
public HashSet<int> MissingTargetChapters { get; set; } = new HashSet<int>();
public HashSet<int> MissingSourceChapters { get; set; } = new HashSet<int>();
}
private class TestEnvironment
{
private readonly MemoryRepository<SFProjectSecret> _projectSecrets;
private readonly IParatextNotesMapper _notesMapper;
public TestEnvironment()
{
IOptions<SiteOptions> siteOptions = Microsoft.Extensions.Options.Options.Create(
new SiteOptions()
{
SiteDir = "scriptureforge"
});
var userSecrets = new MemoryRepository<UserSecret>(new[]
{
new UserSecret { Id = "user01" }
});
_projectSecrets = new MemoryRepository<SFProjectSecret>(new[]
{
new SFProjectSecret { Id = "project01" }
});
SFProjectService = Substitute.For<ISFProjectService>();
EngineService = Substitute.For<IEngineService>();
ParatextService = Substitute.For<IParatextService>();
var ptUserRoles = new Dictionary<string, string>
{
{ "pt01", SFProjectRole.Administrator },
{ "pt02", SFProjectRole.Translator }
};
ParatextService.GetProjectRolesAsync(Arg.Any<UserSecret>(), "target")
.Returns(Task.FromResult<IReadOnlyDictionary<string, string>>(ptUserRoles));
RealtimeService = new SFMemoryRealtimeService();
FileSystemService = Substitute.For<IFileSystemService>();
DeltaUsxMapper = Substitute.For<IDeltaUsxMapper>();
_notesMapper = Substitute.For<IParatextNotesMapper>();
Logger = Substitute.For<ILogger<PtdaSyncRunner>>();
Runner = new PtdaSyncRunner(siteOptions, userSecrets, _projectSecrets, SFProjectService,
EngineService, ParatextService, RealtimeService, FileSystemService, DeltaUsxMapper, _notesMapper,
Logger);
}
public PtdaSyncRunner Runner { get; }
public ISFProjectService SFProjectService { get; }
public IEngineService EngineService { get; }
public IParatextService ParatextService { get; }
public SFMemoryRealtimeService RealtimeService { get; }
public IFileSystemService FileSystemService { get; }
public IDeltaUsxMapper DeltaUsxMapper { get; }
public ILogger<PtdaSyncRunner> Logger { get; }
public SFProject GetProject()
{
return RealtimeService.GetRepository<SFProject>().Get("project01");
}
public SFProjectSecret GetProjectSecret()
{
return _projectSecrets.Get("project01");
}
public bool ContainsText(string bookId, int chapter, TextType textType)
{
return RealtimeService.GetRepository<TextData>()
.Contains(TextData.GetTextDocId("project01", Canon.BookIdToNumber(bookId), chapter, textType));
}
public TextData GetText(string bookId, int chapter, TextType textType)
{
return RealtimeService.GetRepository<TextData>()
.Get(TextData.GetTextDocId("project01", Canon.BookIdToNumber(bookId), chapter, textType));
}
public bool ContainsQuestion(string bookId, int chapter)
{
return RealtimeService.GetRepository<Question>().Contains($"project01:question{bookId}{chapter}");
}
public Question GetQuestion(string bookId, int chapter)
{
return RealtimeService.GetRepository<Question>().Get($"project01:question{bookId}{chapter}");
}
public void SetupSFData(bool translationSuggestionsEnabled, bool checkingEnabled, bool changed,
params Book[] books)
{
RealtimeService.AddRepository("users", OTType.Json0, new MemoryRepository<User>(new[]
{
new User
{
Id = "user01",
ParatextId = "pt01"
},
new User
{
Id = "user02",
ParatextId = "pt02"
}
}));
RealtimeService.AddRepository("sf_projects", OTType.Json0, new MemoryRepository<SFProject>(
new[]
{
new SFProject
{
Id = "project01",
Name = "project01",
ShortName = "P01",
UserRoles = new Dictionary<string, string>
{
{ "user01", SFProjectRole.Administrator },
{ "user02", SFProjectRole.Translator }
},
ParatextId = "target",
TranslateConfig = new TranslateConfig
{
TranslationSuggestionsEnabled = translationSuggestionsEnabled,
Source = new TranslateSource
{
ParatextId = "source",
Name = "Source",
ShortName = "SRC",
WritingSystem = new WritingSystem
{
Tag = "en"
}
}
},
CheckingConfig = new CheckingConfig
{
CheckingEnabled = checkingEnabled
},
Texts = books.Select(b => TextInfoFromBook(b)).ToList(),
Sync = new Sync
{
QueuedCount = 1
}
}
}));
if (books.Length > 0)
{
string targetPath = GetProjectPath(TextType.Target);
FileSystemService.DirectoryExists(targetPath).Returns(true);
FileSystemService.EnumerateFiles(targetPath).Returns(books.Select(b => $"{b.Id}.xml"));
string sourcePath = GetProjectPath(TextType.Source);
FileSystemService.DirectoryExists(sourcePath).Returns(true);
FileSystemService.EnumerateFiles(sourcePath)
.Returns(books.Where(b => b.HighestSourceChapter > 0).Select(b => $"{b.Id}.xml"));
}
RealtimeService.AddRepository("texts", OTType.RichText, new MemoryRepository<TextData>());
RealtimeService.AddRepository("questions", OTType.Json0, new MemoryRepository<Question>());
foreach (Book book in books)
{
AddSFBook(book.Id, book.HighestTargetChapter, TextType.Target, changed, book.MissingTargetChapters);
if (book.HighestSourceChapter > 0)
AddSFBook(book.Id, book.HighestSourceChapter, TextType.Source, changed, book.MissingSourceChapters);
}
var notesElem = new XElement("notes");
var newSyncUsers = new List<SyncUser>();
if (changed)
{
notesElem.Add(new XElement("thread"));
newSyncUsers.Add(new SyncUser { Id = "syncuser01", ParatextUsername = "User 1" });
}
_notesMapper.GetNotesChangelistAsync(Arg.Any<XElement>(),
Arg.Any<IEnumerable<IDocument<Question>>>()).Returns(Task.FromResult(notesElem));
_notesMapper.NewSyncUsers.Returns(newSyncUsers);
}
public TextInfo TextInfoFromBook(Book book)
{
return new TextInfo
{
BookNum = Canon.BookIdToNumber(book.Id),
Chapters = Enumerable.Range(1, book.HighestTargetChapter)
.Select(c => new Chapter
{
Number = c,
LastVerse = 10,
IsValid = !book.InvalidChapters.Contains(c)
}).ToList(),
HasSource = book.HighestSourceChapter > 0
};
}
public void SetupPTData(params Book[] books)
{
ParatextService.GetBooksAsync(Arg.Any<UserSecret>(), "target")
.Returns(books.Select(b => b.Id).ToArray());
// Include book with Source even if there are no chapters, if there are also no chapters in Target. PT
// can actually have or not have books which do or do not have chapters more flexibly than this. But in
// this way, allow tests to request a Source book exist even with zero chapters.
ParatextService.GetBooksAsync(Arg.Any<UserSecret>(), "source")
.Returns(books.Where(b => b.HighestSourceChapter > 0 || b.HighestSourceChapter == b.HighestTargetChapter)
.Select(b => b.Id).ToArray());
foreach (Book book in books)
{
AddPTBook(book.Id, book.HighestTargetChapter, TextType.Target, book.MissingTargetChapters, book.InvalidChapters);
if (book.HighestSourceChapter > 0 || book.HighestSourceChapter == book.HighestTargetChapter)
AddPTBook(book.Id, book.HighestSourceChapter, TextType.Source, book.MissingSourceChapters);
}
}
public static string GetUsxFileName(TextType textType, string bookId)
{
return Path.Combine(GetProjectPath(textType), bookId + ".xml");
}
public static string GetProjectPath(TextType textType)
{
return Path.Combine("scriptureforge", "sync", "project01", GetParatextProject(textType));
}
public Task SetUserRole(string userId, string role)
{
return RealtimeService.GetRepository<SFProject>().UpdateAsync(p => p.Id == "project01", u =>
u.Set(pr => pr.UserRoles[userId], role));
}
private void AddPTBook(string bookId, int highestChapter, TextType textType, HashSet<int> missingChapters,
HashSet<int> invalidChapters = null)
{
string paratextProject = GetParatextProject(textType);
string bookText = GetBookText(textType, bookId, 3);
ParatextService.GetBookTextAsync(Arg.Any<UserSecret>(), paratextProject, bookId)
.Returns(Task.FromResult(bookText));
ParatextService.UpdateBookTextAsync(Arg.Any<UserSecret>(), paratextProject, bookId,
Arg.Any<string>(), Arg.Any<string>()).Returns(Task.FromResult(bookText));
FileSystemService.CreateFile(GetUsxFileName(textType, bookId)).Returns(new MemoryStream());
Func<XDocument, bool> predicate = d => (string)d?.Root?.Element("book")?.Attribute("code") == bookId
&& (string)d?.Root?.Element("book") == paratextProject;
var chapterDeltas = Enumerable.Range(1, highestChapter)
.Where(chapterNumber => !(missingChapters?.Contains(chapterNumber) ?? false))
.Select(c => new ChapterDelta(c, 10, !(invalidChapters?.Contains(c) ?? false),
Delta.New().InsertText("text")));
if (chapterDeltas.Count() == 0)
{
// Add implicit ChapterDelta, mimicing DeltaUsxMapper.ToChapterDeltas().
chapterDeltas = chapterDeltas.Append(new ChapterDelta(1, 0, true, Delta.New()));
}
DeltaUsxMapper.ToChapterDeltas(Arg.Is<XDocument>(d => predicate(d))).Returns(chapterDeltas);
}
private void AddSFBook(string bookId, int highestChapter, TextType textType, bool changed, HashSet<int> missingChapters = null)
{
int bookNum = Canon.BookIdToNumber(bookId);
string oldBookText = GetBookText(textType, bookId, 1);
string filename = GetUsxFileName(textType, bookId);
FileSystemService.OpenFile(filename, FileMode.Open)
.Returns(new MemoryStream(Encoding.UTF8.GetBytes(oldBookText)));
FileSystemService.FileExists(filename).Returns(true);
string newBookText = GetBookText(textType, bookId, changed ? 2 : 1);
DeltaUsxMapper.ToUsx(
Arg.Is<XDocument>(d => (string)d.Root.Element("book").Attribute("code") == bookId
&& (string)d.Root.Element("book") == GetParatextProject(textType)),
Arg.Is<IEnumerable<ChapterDelta>>(
(IEnumerable<ChapterDelta> chapterDeltas) => chapterDeltas.Count() > 0))
.Returns(new XDocument(XElement.Parse(newBookText).Element("usx")));
DeltaUsxMapper.ToUsx(
Arg.Any<XDocument>(),
Arg.Is<IEnumerable<ChapterDelta>>(
(IEnumerable<ChapterDelta> chapterDeltas) => chapterDeltas.Count() == 0))
.Throws<Exception>();
for (int c = 1; c <= highestChapter; c++)
{
string id = TextData.GetTextDocId("project01", bookNum, c, textType);
if (!(missingChapters?.Contains(c) ?? false))
{
RealtimeService.GetRepository<TextData>()
.Add(new TextData(Delta.New().InsertText(changed ? "changed" : "text")) { Id = id });
}
RealtimeService.GetRepository<Question>().Add(new[]
{
new Question
{
Id = $"project01:question{bookId}{c}",
DataId = $"question{bookId}{c}",
ProjectRef = "project01",
VerseRef = new VerseRefData(bookNum, c, 1)
}
});
}
}
private static string GetBookText(TextType textType, string bookId, int version)
{
string projectName = GetParatextProject(textType);
return $"<BookText revision=\"1\"><usx version=\"2.5\"><book code=\"{bookId}\" style=\"id\">{projectName}</book><content version=\"{version}\"/></usx></BookText>";
}
private static string GetBookNotes(TextType textType, string bookId)
{
string projectName = GetParatextProject(textType);
return $"<Notes project=\"{projectName}\" book=\"{bookId}\"/>";
}
private static string GetParatextProject(TextType textType)
{
string projectName;
switch (textType)
{
case TextType.Source:
projectName = "source";
break;
case TextType.Target:
projectName = "target";
break;
default:
throw new InvalidEnumArgumentException(nameof(textType), (int)textType, typeof(TextType));
}
return projectName;
}
}
}
}
| 50.54902 | 179 | 0.583698 | [
"MIT"
] | Nateowami/web-xforge-test | src/Migrations/PtdaSyncAll.Tests/PtdaSyncRunnerTests.cs | 56,716 | C# |
namespace Pyro.DataLayer.MigrationsMicrosoftSQLServer
{
using System;
using System.Collections.Generic;
using System.Data.Entity.Infrastructure.Annotations;
using System.Data.Entity.Migrations;
public partial class CaseSensitive : DbMigration
{
public override void Up()
{
DropIndex("dbo.AccountRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ActivityDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ActivityDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ActivityDefinitionIxTok", "ix_Code");
DropIndex("dbo.AdverseEventRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AdverseEventIxRef", "ix_RefFhirId");
DropIndex("dbo.AdverseEventIxTok", "ix_Code");
DropIndex("dbo.AllergyIntoleranceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AllergyIntoleranceIxRef", "ix_RefFhirId");
DropIndex("dbo.AllergyIntoleranceIxTok", "ix_Code");
DropIndex("dbo.AppointmentRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AppointmentIxRef", "ix_RefFhirId");
DropIndex("dbo.AppointmentIxTok", "ix_Code");
DropIndex("dbo.AppointmentResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AppointmentResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.AppointmentResponseIxTok", "ix_Code");
DropIndex("dbo.AuditEventRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AuditEventIxRef", "ix_RefFhirId");
DropIndex("dbo.AuditEventIxTok", "ix_Code");
DropIndex("dbo.BasicRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BasicIxRef", "ix_RefFhirId");
DropIndex("dbo.BasicIxTok", "ix_Code");
DropIndex("dbo.BinaryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BinaryIxRef", "ix_RefFhirId");
DropIndex("dbo.BinaryIxTok", "ix_Code");
DropIndex("dbo.BiologicallyDerivedProductRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BiologicallyDerivedProductIxRef", "ix_RefFhirId");
DropIndex("dbo.BiologicallyDerivedProductIxTok", "ix_Code");
DropIndex("dbo.BodyStructureRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BodyStructureIxRef", "ix_RefFhirId");
DropIndex("dbo.BodyStructureIxTok", "ix_Code");
DropIndex("dbo.BundleRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BundleIxRef", "ix_RefFhirId");
DropIndex("dbo.BundleIxTok", "ix_Code");
DropIndex("dbo.CapabilityStatementRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CapabilityStatementIxRef", "ix_RefFhirId");
DropIndex("dbo.CapabilityStatementIxTok", "ix_Code");
DropIndex("dbo.CarePlanRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CarePlanIxRef", "ix_RefFhirId");
DropIndex("dbo.CarePlanIxTok", "ix_Code");
DropIndex("dbo.CareTeamRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CareTeamIxRef", "ix_RefFhirId");
DropIndex("dbo.CareTeamIxTok", "ix_Code");
DropIndex("dbo.CatalogEntryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CatalogEntryIxRef", "ix_RefFhirId");
DropIndex("dbo.CatalogEntryIxTok", "ix_Code");
DropIndex("dbo.ChargeItemDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ChargeItemDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ChargeItemDefinitionIxTok", "ix_Code");
DropIndex("dbo.ChargeItemRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ChargeItemIxRef", "ix_RefFhirId");
DropIndex("dbo.ChargeItemIxTok", "ix_Code");
DropIndex("dbo.ClaimRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ClaimIxRef", "ix_RefFhirId");
DropIndex("dbo.ClaimIxTok", "ix_Code");
DropIndex("dbo.ClaimResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ClaimResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.ClaimResponseIxTok", "ix_Code");
DropIndex("dbo.ClinicalImpressionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ClinicalImpressionIxRef", "ix_RefFhirId");
DropIndex("dbo.ClinicalImpressionIxTok", "ix_Code");
DropIndex("dbo.CodeSystemRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CodeSystemIxRef", "ix_RefFhirId");
DropIndex("dbo.CodeSystemIxTok", "ix_Code");
DropIndex("dbo.CommunicationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CommunicationIxRef", "ix_RefFhirId");
DropIndex("dbo.CommunicationIxTok", "ix_Code");
DropIndex("dbo.CommunicationRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CommunicationRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.CommunicationRequestIxTok", "ix_Code");
DropIndex("dbo.CompartmentDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CompartmentDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.CompartmentDefinitionIxTok", "ix_Code");
DropIndex("dbo.CompositionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CompositionIxRef", "ix_RefFhirId");
DropIndex("dbo.CompositionIxTok", "ix_Code");
DropIndex("dbo.ConceptMapRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ConceptMapIxRef", "ix_RefFhirId");
DropIndex("dbo.ConceptMapIxTok", "ix_Code");
DropIndex("dbo.ConditionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ConditionIxRef", "ix_RefFhirId");
DropIndex("dbo.ConditionIxTok", "ix_Code");
DropIndex("dbo.ConsentRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ConsentIxRef", "ix_RefFhirId");
DropIndex("dbo.ConsentIxTok", "ix_Code");
DropIndex("dbo.ContractRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ContractIxRef", "ix_RefFhirId");
DropIndex("dbo.ContractIxTok", "ix_Code");
DropIndex("dbo.CoverageEligibilityRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CoverageEligibilityRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.CoverageEligibilityRequestIxTok", "ix_Code");
DropIndex("dbo.CoverageEligibilityResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CoverageEligibilityResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.CoverageEligibilityResponseIxTok", "ix_Code");
DropIndex("dbo.CoverageRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CoverageIxRef", "ix_RefFhirId");
DropIndex("dbo.CoverageIxTok", "ix_Code");
DropIndex("dbo.DetectedIssueRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DetectedIssueIxRef", "ix_RefFhirId");
DropIndex("dbo.DetectedIssueIxTok", "ix_Code");
DropIndex("dbo.DeviceDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceDefinitionIxTok", "ix_Code");
DropIndex("dbo.DeviceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceIxTok", "ix_Code");
DropIndex("dbo.DeviceMetricRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceMetricIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceMetricIxTok", "ix_Code");
DropIndex("dbo.DeviceRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceRequestIxTok", "ix_Code");
DropIndex("dbo.DeviceUseStatementRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceUseStatementIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceUseStatementIxTok", "ix_Code");
DropIndex("dbo.DiagnosticReportRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DiagnosticReportIxRef", "ix_RefFhirId");
DropIndex("dbo.DiagnosticReportIxTok", "ix_Code");
DropIndex("dbo.DocumentManifestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DocumentManifestIxRef", "ix_RefFhirId");
DropIndex("dbo.DocumentManifestIxTok", "ix_Code");
DropIndex("dbo.DocumentReferenceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DocumentReferenceIxRef", "ix_RefFhirId");
DropIndex("dbo.DocumentReferenceIxTok", "ix_Code");
DropIndex("dbo.EffectEvidenceSynthesisRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EffectEvidenceSynthesisIxRef", "ix_RefFhirId");
DropIndex("dbo.EffectEvidenceSynthesisIxTok", "ix_Code");
DropIndex("dbo.EncounterRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EncounterIxRef", "ix_RefFhirId");
DropIndex("dbo.EncounterIxTok", "ix_Code");
DropIndex("dbo.EndpointRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EndpointIxRef", "ix_RefFhirId");
DropIndex("dbo.EndpointIxTok", "ix_Code");
DropIndex("dbo.EnrollmentRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EnrollmentRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.EnrollmentRequestIxTok", "ix_Code");
DropIndex("dbo.EnrollmentResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EnrollmentResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.EnrollmentResponseIxTok", "ix_Code");
DropIndex("dbo.EpisodeOfCareRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EpisodeOfCareIxRef", "ix_RefFhirId");
DropIndex("dbo.EpisodeOfCareIxTok", "ix_Code");
DropIndex("dbo.EventDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EventDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.EventDefinitionIxTok", "ix_Code");
DropIndex("dbo.EvidenceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EvidenceIxRef", "ix_RefFhirId");
DropIndex("dbo.EvidenceIxTok", "ix_Code");
DropIndex("dbo.EvidenceVariableRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EvidenceVariableIxRef", "ix_RefFhirId");
DropIndex("dbo.EvidenceVariableIxTok", "ix_Code");
DropIndex("dbo.ExampleScenarioRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ExampleScenarioIxRef", "ix_RefFhirId");
DropIndex("dbo.ExampleScenarioIxTok", "ix_Code");
DropIndex("dbo.ExplanationOfBenefitRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ExplanationOfBenefitIxRef", "ix_RefFhirId");
DropIndex("dbo.ExplanationOfBenefitIxTok", "ix_Code");
DropIndex("dbo.FamilyMemberHistoryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.FamilyMemberHistoryIxRef", "ix_RefFhirId");
DropIndex("dbo.FamilyMemberHistoryIxTok", "ix_Code");
DropIndex("dbo.FlagRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.FlagIxRef", "ix_RefFhirId");
DropIndex("dbo.FlagIxTok", "ix_Code");
DropIndex("dbo.GoalRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.GoalIxRef", "ix_RefFhirId");
DropIndex("dbo.GoalIxTok", "ix_Code");
DropIndex("dbo.GraphDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.GraphDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.GraphDefinitionIxTok", "ix_Code");
DropIndex("dbo.GroupRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.GroupIxRef", "ix_RefFhirId");
DropIndex("dbo.GroupIxTok", "ix_Code");
DropIndex("dbo.GuidanceResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.GuidanceResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.GuidanceResponseIxTok", "ix_Code");
DropIndex("dbo.HealthcareServiceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.HealthcareServiceIxRef", "ix_RefFhirId");
DropIndex("dbo.HealthcareServiceIxTok", "ix_Code");
DropIndex("dbo.ImagingStudyRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImagingStudyIxRef", "ix_RefFhirId");
DropIndex("dbo.ImagingStudyIxTok", "ix_Code");
DropIndex("dbo.ImmunizationEvaluationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImmunizationEvaluationIxRef", "ix_RefFhirId");
DropIndex("dbo.ImmunizationEvaluationIxTok", "ix_Code");
DropIndex("dbo.ImmunizationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImmunizationIxRef", "ix_RefFhirId");
DropIndex("dbo.ImmunizationIxTok", "ix_Code");
DropIndex("dbo.ImmunizationRecommendationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImmunizationRecommendationIxRef", "ix_RefFhirId");
DropIndex("dbo.ImmunizationRecommendationIxTok", "ix_Code");
DropIndex("dbo.ImplementationGuideRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImplementationGuideIxRef", "ix_RefFhirId");
DropIndex("dbo.ImplementationGuideIxTok", "ix_Code");
DropIndex("dbo.InsurancePlanRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.InsurancePlanIxRef", "ix_RefFhirId");
DropIndex("dbo.InsurancePlanIxTok", "ix_Code");
DropIndex("dbo.InvoiceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.InvoiceIxRef", "ix_RefFhirId");
DropIndex("dbo.InvoiceIxTok", "ix_Code");
DropIndex("dbo.LibraryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.LibraryIxRef", "ix_RefFhirId");
DropIndex("dbo.LibraryIxTok", "ix_Code");
DropIndex("dbo.LinkageRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.LinkageIxRef", "ix_RefFhirId");
DropIndex("dbo.LinkageIxTok", "ix_Code");
DropIndex("dbo.ListRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ListIxRef", "ix_RefFhirId");
DropIndex("dbo.ListIxTok", "ix_Code");
DropIndex("dbo.LocationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.LocationIxRef", "ix_RefFhirId");
DropIndex("dbo.LocationIxTok", "ix_Code");
DropIndex("dbo.MeasureRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MeasureIxRef", "ix_RefFhirId");
DropIndex("dbo.MeasureIxTok", "ix_Code");
DropIndex("dbo.MeasureReportRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MeasureReportIxRef", "ix_RefFhirId");
DropIndex("dbo.MeasureReportIxTok", "ix_Code");
DropIndex("dbo.MediaRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MediaIxRef", "ix_RefFhirId");
DropIndex("dbo.MediaIxTok", "ix_Code");
DropIndex("dbo.MedicationAdministrationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationAdministrationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationAdministrationIxTok", "ix_Code");
DropIndex("dbo.MedicationDispenseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationDispenseIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationDispenseIxTok", "ix_Code");
DropIndex("dbo.MedicationKnowledgeRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationKnowledgeIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationKnowledgeIxTok", "ix_Code");
DropIndex("dbo.MedicationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationIxTok", "ix_Code");
DropIndex("dbo.MedicationRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationRequestIxTok", "ix_Code");
DropIndex("dbo.MedicationStatementRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationStatementIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationStatementIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductAuthorizationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductAuthorizationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductAuthorizationIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductContraindicationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductContraindicationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductContraindicationIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductIndicationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductIndicationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductIndicationIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductIngredientRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductIngredientIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductIngredientIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductInteractionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductInteractionIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductInteractionIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductManufacturedRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductManufacturedIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductManufacturedIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductPackagedRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductPackagedIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductPackagedIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductPharmaceuticalRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductPharmaceuticalIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductPharmaceuticalIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductUndesirableEffectRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductUndesirableEffectIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductUndesirableEffectIxTok", "ix_Code");
DropIndex("dbo.MessageDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MessageDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.MessageDefinitionIxTok", "ix_Code");
DropIndex("dbo.MessageHeaderRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MessageHeaderIxRef", "ix_RefFhirId");
DropIndex("dbo.MessageHeaderIxTok", "ix_Code");
DropIndex("dbo.MolecularSequenceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MolecularSequenceIxRef", "ix_RefFhirId");
DropIndex("dbo.MolecularSequenceIxTok", "ix_Code");
DropIndex("dbo.NamingSystemRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.NamingSystemIxRef", "ix_RefFhirId");
DropIndex("dbo.NamingSystemIxTok", "ix_Code");
DropIndex("dbo.NutritionOrderRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.NutritionOrderIxRef", "ix_RefFhirId");
DropIndex("dbo.NutritionOrderIxTok", "ix_Code");
DropIndex("dbo.ObservationDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ObservationDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ObservationDefinitionIxTok", "ix_Code");
DropIndex("dbo.ObservationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ObservationIxRef", "ix_RefFhirId");
DropIndex("dbo.ObservationIxTok", "ix_Code");
DropIndex("dbo.OperationDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.OperationDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.OperationDefinitionIxTok", "ix_Code");
DropIndex("dbo.OperationOutcomeRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.OperationOutcomeIxRef", "ix_RefFhirId");
DropIndex("dbo.OperationOutcomeIxTok", "ix_Code");
DropIndex("dbo.OrganizationAffiliationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.OrganizationAffiliationIxRef", "ix_RefFhirId");
DropIndex("dbo.OrganizationAffiliationIxTok", "ix_Code");
DropIndex("dbo.OrganizationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.OrganizationIxRef", "ix_RefFhirId");
DropIndex("dbo.OrganizationIxTok", "ix_Code");
DropIndex("dbo.ParametersRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ParametersIxRef", "ix_RefFhirId");
DropIndex("dbo.ParametersIxTok", "ix_Code");
DropIndex("dbo.PatientRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PatientIxRef", "ix_RefFhirId");
DropIndex("dbo.PatientIxTok", "ix_Code");
DropIndex("dbo.PaymentNoticeRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PaymentNoticeIxRef", "ix_RefFhirId");
DropIndex("dbo.PaymentNoticeIxTok", "ix_Code");
DropIndex("dbo.PaymentReconciliationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PaymentReconciliationIxRef", "ix_RefFhirId");
DropIndex("dbo.PaymentReconciliationIxTok", "ix_Code");
DropIndex("dbo.PersonRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PersonIxRef", "ix_RefFhirId");
DropIndex("dbo.PersonIxTok", "ix_Code");
DropIndex("dbo.PlanDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PlanDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.PlanDefinitionIxTok", "ix_Code");
DropIndex("dbo.PractitionerRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PractitionerIxRef", "ix_RefFhirId");
DropIndex("dbo.PractitionerIxTok", "ix_Code");
DropIndex("dbo.PractitionerRoleRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PractitionerRoleIxRef", "ix_RefFhirId");
DropIndex("dbo.PractitionerRoleIxTok", "ix_Code");
DropIndex("dbo.ProcedureRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ProcedureIxRef", "ix_RefFhirId");
DropIndex("dbo.ProcedureIxTok", "ix_Code");
DropIndex("dbo.ProvenanceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ProvenanceIxRef", "ix_RefFhirId");
DropIndex("dbo.ProvenanceIxTok", "ix_Code");
DropIndex("dbo.QuestionnaireRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.QuestionnaireIxRef", "ix_RefFhirId");
DropIndex("dbo.QuestionnaireIxTok", "ix_Code");
DropIndex("dbo.QuestionnaireResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.QuestionnaireResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.QuestionnaireResponseIxTok", "ix_Code");
DropIndex("dbo.RelatedPersonRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.RelatedPersonIxRef", "ix_RefFhirId");
DropIndex("dbo.RelatedPersonIxTok", "ix_Code");
DropIndex("dbo.RequestGroupRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.RequestGroupIxRef", "ix_RefFhirId");
DropIndex("dbo.RequestGroupIxTok", "ix_Code");
DropIndex("dbo.ResearchDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ResearchDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ResearchDefinitionIxTok", "ix_Code");
DropIndex("dbo.ResearchElementDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ResearchElementDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ResearchElementDefinitionIxTok", "ix_Code");
DropIndex("dbo.ResearchStudyRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ResearchStudyIxRef", "ix_RefFhirId");
DropIndex("dbo.ResearchStudyIxTok", "ix_Code");
DropIndex("dbo.ResearchSubjectRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ResearchSubjectIxRef", "ix_RefFhirId");
DropIndex("dbo.ResearchSubjectIxTok", "ix_Code");
DropIndex("dbo.RiskAssessmentRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.RiskAssessmentIxRef", "ix_RefFhirId");
DropIndex("dbo.RiskAssessmentIxTok", "ix_Code");
DropIndex("dbo.RiskEvidenceSynthesisRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.RiskEvidenceSynthesisIxRef", "ix_RefFhirId");
DropIndex("dbo.RiskEvidenceSynthesisIxTok", "ix_Code");
DropIndex("dbo.ScheduleRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ScheduleIxRef", "ix_RefFhirId");
DropIndex("dbo.ScheduleIxTok", "ix_Code");
DropIndex("dbo.SearchParameterRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SearchParameterIxRef", "ix_RefFhirId");
DropIndex("dbo.SearchParameterIxTok", "ix_Code");
DropIndex("dbo.ServiceRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ServiceRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.ServiceRequestIxTok", "ix_Code");
DropIndex("dbo.SlotRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SlotIxRef", "ix_RefFhirId");
DropIndex("dbo.SlotIxTok", "ix_Code");
DropIndex("dbo.SpecimenDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SpecimenDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.SpecimenDefinitionIxTok", "ix_Code");
DropIndex("dbo.SpecimenRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SpecimenIxRef", "ix_RefFhirId");
DropIndex("dbo.SpecimenIxTok", "ix_Code");
DropIndex("dbo.StructureDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.StructureDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.StructureDefinitionIxTok", "ix_Code");
DropIndex("dbo.StructureMapRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.StructureMapIxRef", "ix_RefFhirId");
DropIndex("dbo.StructureMapIxTok", "ix_Code");
DropIndex("dbo.SubscriptionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubscriptionIxRef", "ix_RefFhirId");
DropIndex("dbo.SubscriptionIxTok", "ix_Code");
DropIndex("dbo.SubstanceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceIxTok", "ix_Code");
DropIndex("dbo.SubstanceNucleicAcidRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceNucleicAcidIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceNucleicAcidIxTok", "ix_Code");
DropIndex("dbo.SubstancePolymerRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstancePolymerIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstancePolymerIxTok", "ix_Code");
DropIndex("dbo.SubstanceProteinRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceProteinIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceProteinIxTok", "ix_Code");
DropIndex("dbo.SubstanceReferenceInformationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceReferenceInformationIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceReferenceInformationIxTok", "ix_Code");
DropIndex("dbo.SubstanceSourceMaterialRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceSourceMaterialIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceSourceMaterialIxTok", "ix_Code");
DropIndex("dbo.SubstanceSpecificationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceSpecificationIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceSpecificationIxTok", "ix_Code");
DropIndex("dbo.SupplyDeliveryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SupplyDeliveryIxRef", "ix_RefFhirId");
DropIndex("dbo.SupplyDeliveryIxTok", "ix_Code");
DropIndex("dbo.SupplyRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SupplyRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.SupplyRequestIxTok", "ix_Code");
DropIndex("dbo.TaskRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.TaskIxRef", "ix_RefFhirId");
DropIndex("dbo.TaskIxTok", "ix_Code");
DropIndex("dbo.TerminologyCapabilitiesRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.TerminologyCapabilitiesIxRef", "ix_RefFhirId");
DropIndex("dbo.TerminologyCapabilitiesIxTok", "ix_Code");
DropIndex("dbo.TestReportRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.TestReportIxRef", "ix_RefFhirId");
DropIndex("dbo.TestReportIxTok", "ix_Code");
DropIndex("dbo.TestScriptRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.TestScriptIxRef", "ix_RefFhirId");
DropIndex("dbo.TestScriptIxTok", "ix_Code");
DropIndex("dbo.ValueSetRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ValueSetIxRef", "ix_RefFhirId");
DropIndex("dbo.ValueSetIxTok", "ix_Code");
DropIndex("dbo.VerificationResultRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.VerificationResultIxRef", "ix_RefFhirId");
DropIndex("dbo.VerificationResultIxTok", "ix_Code");
DropIndex("dbo.VisionPrescriptionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.VisionPrescriptionIxRef", "ix_RefFhirId");
DropIndex("dbo.VisionPrescriptionIxTok", "ix_Code");
DropIndex("dbo.AccountIxRef", "ix_RefFhirId");
DropIndex("dbo.AccountIxTok", "ix_Code");
AlterColumn("dbo.AccountRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AccountRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ActivityDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ActivityDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ActivityDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ActivityDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ActivityDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AdverseEventRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AdverseEventRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AdverseEventIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AdverseEventIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AdverseEventIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AllergyIntoleranceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AllergyIntoleranceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AllergyIntoleranceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AllergyIntoleranceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AllergyIntoleranceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AppointmentResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AuditEventRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AuditEventRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AuditEventIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AuditEventIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AuditEventIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BasicRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BasicRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BasicIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BasicIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BasicIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BinaryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BinaryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BinaryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BinaryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BinaryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BiologicallyDerivedProductRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BiologicallyDerivedProductRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BiologicallyDerivedProductIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BiologicallyDerivedProductIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BiologicallyDerivedProductIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BodyStructureRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BodyStructureRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BodyStructureIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BodyStructureIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BodyStructureIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BundleRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BundleRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BundleIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BundleIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.BundleIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CapabilityStatementRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CapabilityStatementRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CapabilityStatementIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CapabilityStatementIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CapabilityStatementIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CarePlanRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CarePlanRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CarePlanIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CarePlanIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CarePlanIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CareTeamRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CareTeamRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CareTeamIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CareTeamIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CareTeamIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CatalogEntryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CatalogEntryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CatalogEntryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CatalogEntryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CatalogEntryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ChargeItemIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClaimResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClinicalImpressionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClinicalImpressionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClinicalImpressionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClinicalImpressionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ClinicalImpressionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CodeSystemRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CodeSystemRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CodeSystemIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CodeSystemIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CodeSystemIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CommunicationRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompartmentDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompartmentDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompartmentDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompartmentDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompartmentDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompositionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompositionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompositionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompositionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CompositionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConceptMapRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConceptMapRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConceptMapIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConceptMapIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConceptMapIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConditionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConditionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConditionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConditionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConditionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConsentRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConsentRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConsentIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConsentIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ConsentIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ContractRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ContractRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ContractIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ContractIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ContractIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageEligibilityResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.CoverageIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DetectedIssueRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DetectedIssueRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DetectedIssueIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DetectedIssueIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DetectedIssueIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceMetricRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceMetricRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceMetricIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceMetricIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceMetricIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceUseStatementRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceUseStatementRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceUseStatementIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceUseStatementIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DeviceUseStatementIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DiagnosticReportRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DiagnosticReportRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DiagnosticReportIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DiagnosticReportIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DiagnosticReportIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentManifestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentManifestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentManifestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentManifestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentManifestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentReferenceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentReferenceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentReferenceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentReferenceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.DocumentReferenceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EncounterRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EncounterRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EncounterIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EncounterIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EncounterIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EndpointRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EndpointRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EndpointIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EndpointIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EndpointIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EnrollmentResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EpisodeOfCareRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EpisodeOfCareRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EpisodeOfCareIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EpisodeOfCareIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EpisodeOfCareIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EventDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EventDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EventDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EventDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EventDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceVariableRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceVariableRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceVariableIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceVariableIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.EvidenceVariableIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExampleScenarioRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExampleScenarioRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExampleScenarioIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExampleScenarioIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExampleScenarioIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExplanationOfBenefitRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExplanationOfBenefitRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExplanationOfBenefitIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExplanationOfBenefitIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ExplanationOfBenefitIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FamilyMemberHistoryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FamilyMemberHistoryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FamilyMemberHistoryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FamilyMemberHistoryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FamilyMemberHistoryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FlagRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FlagRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FlagIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FlagIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.FlagIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GoalRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GoalRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GoalIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GoalIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GoalIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GraphDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GraphDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GraphDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GraphDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GraphDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GroupRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GroupRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GroupIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GroupIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GroupIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GuidanceResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GuidanceResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GuidanceResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GuidanceResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.GuidanceResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.HealthcareServiceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.HealthcareServiceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.HealthcareServiceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.HealthcareServiceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.HealthcareServiceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImagingStudyRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImagingStudyRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImagingStudyIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImagingStudyIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImagingStudyIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationEvaluationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationEvaluationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationEvaluationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationEvaluationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationEvaluationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationRecommendationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationRecommendationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationRecommendationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationRecommendationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImmunizationRecommendationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImplementationGuideRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImplementationGuideRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImplementationGuideIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImplementationGuideIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ImplementationGuideIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InsurancePlanRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InsurancePlanRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InsurancePlanIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InsurancePlanIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InsurancePlanIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InvoiceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InvoiceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InvoiceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InvoiceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.InvoiceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LibraryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LibraryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LibraryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LibraryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LibraryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LinkageRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LinkageRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LinkageIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LinkageIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LinkageIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ListRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ListRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ListIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ListIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ListIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LocationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LocationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LocationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LocationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.LocationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureReportRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureReportRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureReportIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureReportIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MeasureReportIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MediaRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MediaRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MediaIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MediaIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MediaIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationAdministrationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationAdministrationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationAdministrationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationAdministrationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationAdministrationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationDispenseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationDispenseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationDispenseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationDispenseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationDispenseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationKnowledgeRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationKnowledgeRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationKnowledgeIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationKnowledgeIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationKnowledgeIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationStatementRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationStatementRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationStatementIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationStatementIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicationStatementIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductContraindicationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductContraindicationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductContraindicationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductContraindicationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductContraindicationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIndicationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIndicationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIndicationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIndicationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIndicationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIngredientRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIngredientRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIngredientIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIngredientIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIngredientIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductInteractionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductInteractionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductInteractionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductInteractionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductInteractionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductManufacturedRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductManufacturedRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductManufacturedIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductManufacturedIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductManufacturedIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPackagedRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPackagedRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPackagedIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPackagedIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPackagedIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageHeaderRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageHeaderRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageHeaderIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageHeaderIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MessageHeaderIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MolecularSequenceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MolecularSequenceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MolecularSequenceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MolecularSequenceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.MolecularSequenceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NamingSystemRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NamingSystemRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NamingSystemIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NamingSystemIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NamingSystemIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NutritionOrderRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NutritionOrderRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NutritionOrderIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NutritionOrderIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.NutritionOrderIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ObservationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationOutcomeRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationOutcomeRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationOutcomeIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationOutcomeIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OperationOutcomeIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationAffiliationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationAffiliationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationAffiliationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationAffiliationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationAffiliationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.OrganizationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ParametersRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ParametersRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ParametersIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ParametersIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ParametersIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PatientRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PatientRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PatientIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PatientIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PatientIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentNoticeRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentNoticeRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentNoticeIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentNoticeIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentNoticeIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentReconciliationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentReconciliationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentReconciliationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentReconciliationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PaymentReconciliationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PersonRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PersonRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PersonIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PersonIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PersonIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PlanDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PlanDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PlanDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PlanDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PlanDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerRoleRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerRoleRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerRoleIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerRoleIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.PractitionerRoleIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProcedureRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProcedureRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProcedureIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProcedureIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProcedureIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProvenanceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProvenanceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProvenanceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProvenanceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ProvenanceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.QuestionnaireResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RelatedPersonRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RelatedPersonRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RelatedPersonIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RelatedPersonIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RelatedPersonIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RequestGroupRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RequestGroupRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RequestGroupIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RequestGroupIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RequestGroupIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchElementDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchElementDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchElementDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchElementDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchElementDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchStudyRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchStudyRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchStudyIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchStudyIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchStudyIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchSubjectRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchSubjectRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchSubjectIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchSubjectIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ResearchSubjectIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskAssessmentRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskAssessmentRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskAssessmentIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskAssessmentIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskAssessmentIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ScheduleRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ScheduleRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ScheduleIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ScheduleIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ScheduleIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SearchParameterRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SearchParameterRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SearchParameterIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SearchParameterIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SearchParameterIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ServiceRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ServiceRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ServiceRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ServiceRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ServiceRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SlotRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SlotRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SlotIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SlotIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SlotIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SpecimenIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureMapRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureMapRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureMapIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureMapIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.StructureMapIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubscriptionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubscriptionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubscriptionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubscriptionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubscriptionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceNucleicAcidRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceNucleicAcidRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceNucleicAcidIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceNucleicAcidIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceNucleicAcidIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstancePolymerRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstancePolymerRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstancePolymerIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstancePolymerIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstancePolymerIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceProteinRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceProteinRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceProteinIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceProteinIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceProteinIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceReferenceInformationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceReferenceInformationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceReferenceInformationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceReferenceInformationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceReferenceInformationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSourceMaterialRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSourceMaterialRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSourceMaterialIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSourceMaterialIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSourceMaterialIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSpecificationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSpecificationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSpecificationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSpecificationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SubstanceSpecificationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyDeliveryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyDeliveryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyDeliveryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyDeliveryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyDeliveryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.SupplyRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TaskRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TaskRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TaskIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TaskIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TaskIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TerminologyCapabilitiesRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TerminologyCapabilitiesRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TerminologyCapabilitiesIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TerminologyCapabilitiesIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TerminologyCapabilitiesIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestReportRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestReportRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestReportIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestReportIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestReportIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestScriptRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestScriptRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestScriptIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestScriptIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.TestScriptIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ValueSetRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ValueSetRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ValueSetIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ValueSetIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.ValueSetIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VerificationResultRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VerificationResultRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VerificationResultIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VerificationResultIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VerificationResultIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VisionPrescriptionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VisionPrescriptionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VisionPrescriptionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VisionPrescriptionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.VisionPrescriptionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AccountIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AccountIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
AlterColumn("dbo.AccountIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: null, newValue: "True")
},
}));
CreateIndex("dbo.AccountRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ActivityDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ActivityDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ActivityDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AdverseEventRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AdverseEventIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AdverseEventIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AllergyIntoleranceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AllergyIntoleranceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AllergyIntoleranceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AppointmentRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AppointmentIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AppointmentIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AppointmentResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AppointmentResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AppointmentResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AuditEventRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AuditEventIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AuditEventIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BasicRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BasicIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BasicIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BinaryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BinaryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BinaryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BiologicallyDerivedProductRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BiologicallyDerivedProductIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BiologicallyDerivedProductIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BodyStructureRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BodyStructureIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BodyStructureIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BundleRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BundleIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BundleIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CapabilityStatementRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CapabilityStatementIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CapabilityStatementIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CarePlanRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CarePlanIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CarePlanIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CareTeamRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CareTeamIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CareTeamIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CatalogEntryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CatalogEntryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CatalogEntryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ChargeItemDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ChargeItemDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ChargeItemDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ChargeItemRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ChargeItemIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ChargeItemIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ClaimRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ClaimIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ClaimIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ClaimResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ClaimResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ClaimResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ClinicalImpressionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ClinicalImpressionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ClinicalImpressionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CodeSystemRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CodeSystemIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CodeSystemIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CommunicationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CommunicationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CommunicationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CommunicationRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CommunicationRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CommunicationRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CompartmentDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CompartmentDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CompartmentDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CompositionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CompositionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CompositionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ConceptMapRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ConceptMapIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ConceptMapIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ConditionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ConditionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ConditionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ConsentRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ConsentIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ConsentIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ContractRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ContractIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ContractIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CoverageEligibilityRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CoverageEligibilityRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CoverageEligibilityRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CoverageEligibilityResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CoverageEligibilityResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CoverageEligibilityResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CoverageRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CoverageIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CoverageIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DetectedIssueRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DetectedIssueIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DetectedIssueIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceMetricRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceMetricIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceMetricIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceUseStatementRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceUseStatementIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceUseStatementIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DiagnosticReportRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DiagnosticReportIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DiagnosticReportIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DocumentManifestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DocumentManifestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DocumentManifestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DocumentReferenceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DocumentReferenceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DocumentReferenceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EffectEvidenceSynthesisRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EffectEvidenceSynthesisIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EffectEvidenceSynthesisIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EncounterRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EncounterIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EncounterIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EndpointRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EndpointIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EndpointIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EnrollmentRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EnrollmentRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EnrollmentRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EnrollmentResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EnrollmentResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EnrollmentResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EpisodeOfCareRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EpisodeOfCareIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EpisodeOfCareIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EventDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EventDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EventDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EvidenceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EvidenceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EvidenceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EvidenceVariableRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EvidenceVariableIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EvidenceVariableIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ExampleScenarioRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ExampleScenarioIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ExampleScenarioIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ExplanationOfBenefitRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ExplanationOfBenefitIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ExplanationOfBenefitIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.FamilyMemberHistoryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.FamilyMemberHistoryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.FamilyMemberHistoryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.FlagRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.FlagIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.FlagIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.GoalRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.GoalIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.GoalIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.GraphDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.GraphDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.GraphDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.GroupRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.GroupIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.GroupIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.GuidanceResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.GuidanceResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.GuidanceResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.HealthcareServiceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.HealthcareServiceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.HealthcareServiceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImagingStudyRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImagingStudyIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImagingStudyIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImmunizationEvaluationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImmunizationEvaluationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImmunizationEvaluationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImmunizationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImmunizationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImmunizationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImmunizationRecommendationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImmunizationRecommendationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImmunizationRecommendationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImplementationGuideRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImplementationGuideIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImplementationGuideIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.InsurancePlanRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.InsurancePlanIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.InsurancePlanIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.InvoiceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.InvoiceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.InvoiceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.LibraryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.LibraryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.LibraryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.LinkageRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.LinkageIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.LinkageIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ListRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ListIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ListIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.LocationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.LocationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.LocationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MeasureRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MeasureIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MeasureIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MeasureReportRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MeasureReportIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MeasureReportIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MediaRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MediaIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MediaIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationAdministrationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationAdministrationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationAdministrationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationDispenseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationDispenseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationDispenseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationKnowledgeRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationKnowledgeIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationKnowledgeIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationStatementRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationStatementIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationStatementIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductAuthorizationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductAuthorizationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductAuthorizationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductContraindicationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductContraindicationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductContraindicationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductIndicationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductIndicationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductIndicationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductIngredientRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductIngredientIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductIngredientIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductInteractionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductInteractionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductInteractionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductManufacturedRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductManufacturedIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductManufacturedIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductPackagedRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductPackagedIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductPackagedIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductPharmaceuticalRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductPharmaceuticalIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductPharmaceuticalIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductUndesirableEffectRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductUndesirableEffectIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductUndesirableEffectIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MessageDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MessageDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MessageDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MessageHeaderRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MessageHeaderIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MessageHeaderIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MolecularSequenceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MolecularSequenceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MolecularSequenceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.NamingSystemRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.NamingSystemIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.NamingSystemIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.NutritionOrderRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.NutritionOrderIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.NutritionOrderIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ObservationDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ObservationDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ObservationDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ObservationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ObservationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ObservationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.OperationDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.OperationDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.OperationDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.OperationOutcomeRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.OperationOutcomeIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.OperationOutcomeIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.OrganizationAffiliationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.OrganizationAffiliationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.OrganizationAffiliationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.OrganizationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.OrganizationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.OrganizationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ParametersRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ParametersIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ParametersIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PatientRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PatientIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PatientIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PaymentNoticeRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PaymentNoticeIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PaymentNoticeIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PaymentReconciliationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PaymentReconciliationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PaymentReconciliationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PersonRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PersonIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PersonIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PlanDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PlanDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PlanDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PractitionerRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PractitionerIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PractitionerIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PractitionerRoleRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PractitionerRoleIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PractitionerRoleIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ProcedureRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ProcedureIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ProcedureIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ProvenanceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ProvenanceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ProvenanceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.QuestionnaireRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.QuestionnaireIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.QuestionnaireIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.QuestionnaireResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.QuestionnaireResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.QuestionnaireResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.RelatedPersonRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.RelatedPersonIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.RelatedPersonIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.RequestGroupRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.RequestGroupIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.RequestGroupIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ResearchDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ResearchDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ResearchDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ResearchElementDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ResearchElementDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ResearchElementDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ResearchStudyRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ResearchStudyIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ResearchStudyIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ResearchSubjectRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ResearchSubjectIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ResearchSubjectIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.RiskAssessmentRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.RiskAssessmentIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.RiskAssessmentIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.RiskEvidenceSynthesisRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.RiskEvidenceSynthesisIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.RiskEvidenceSynthesisIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ScheduleRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ScheduleIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ScheduleIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SearchParameterRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SearchParameterIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SearchParameterIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ServiceRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ServiceRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ServiceRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SlotRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SlotIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SlotIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SpecimenDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SpecimenDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SpecimenDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SpecimenRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SpecimenIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SpecimenIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.StructureDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.StructureDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.StructureDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.StructureMapRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.StructureMapIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.StructureMapIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubscriptionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubscriptionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubscriptionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceNucleicAcidRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceNucleicAcidIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceNucleicAcidIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstancePolymerRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstancePolymerIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstancePolymerIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceProteinRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceProteinIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceProteinIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceReferenceInformationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceReferenceInformationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceReferenceInformationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceSourceMaterialRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceSourceMaterialIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceSourceMaterialIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceSpecificationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceSpecificationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceSpecificationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SupplyDeliveryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SupplyDeliveryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SupplyDeliveryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SupplyRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SupplyRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SupplyRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.TaskRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.TaskIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.TaskIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.TerminologyCapabilitiesRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.TerminologyCapabilitiesIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.TerminologyCapabilitiesIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.TestReportRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.TestReportIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.TestReportIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.TestScriptRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.TestScriptIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.TestScriptIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ValueSetRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ValueSetIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ValueSetIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.VerificationResultRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.VerificationResultIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.VerificationResultIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.VisionPrescriptionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.VisionPrescriptionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.VisionPrescriptionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AccountIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AccountIxTok", "Code", name: "ix_Code");
}
public override void Down()
{
DropIndex("dbo.AccountIxTok", "ix_Code");
DropIndex("dbo.AccountIxRef", "ix_RefFhirId");
DropIndex("dbo.VisionPrescriptionIxTok", "ix_Code");
DropIndex("dbo.VisionPrescriptionIxRef", "ix_RefFhirId");
DropIndex("dbo.VisionPrescriptionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.VerificationResultIxTok", "ix_Code");
DropIndex("dbo.VerificationResultIxRef", "ix_RefFhirId");
DropIndex("dbo.VerificationResultRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ValueSetIxTok", "ix_Code");
DropIndex("dbo.ValueSetIxRef", "ix_RefFhirId");
DropIndex("dbo.ValueSetRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.TestScriptIxTok", "ix_Code");
DropIndex("dbo.TestScriptIxRef", "ix_RefFhirId");
DropIndex("dbo.TestScriptRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.TestReportIxTok", "ix_Code");
DropIndex("dbo.TestReportIxRef", "ix_RefFhirId");
DropIndex("dbo.TestReportRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.TerminologyCapabilitiesIxTok", "ix_Code");
DropIndex("dbo.TerminologyCapabilitiesIxRef", "ix_RefFhirId");
DropIndex("dbo.TerminologyCapabilitiesRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.TaskIxTok", "ix_Code");
DropIndex("dbo.TaskIxRef", "ix_RefFhirId");
DropIndex("dbo.TaskRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SupplyRequestIxTok", "ix_Code");
DropIndex("dbo.SupplyRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.SupplyRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SupplyDeliveryIxTok", "ix_Code");
DropIndex("dbo.SupplyDeliveryIxRef", "ix_RefFhirId");
DropIndex("dbo.SupplyDeliveryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceSpecificationIxTok", "ix_Code");
DropIndex("dbo.SubstanceSpecificationIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceSpecificationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceSourceMaterialIxTok", "ix_Code");
DropIndex("dbo.SubstanceSourceMaterialIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceSourceMaterialRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceReferenceInformationIxTok", "ix_Code");
DropIndex("dbo.SubstanceReferenceInformationIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceReferenceInformationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceProteinIxTok", "ix_Code");
DropIndex("dbo.SubstanceProteinIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceProteinRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstancePolymerIxTok", "ix_Code");
DropIndex("dbo.SubstancePolymerIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstancePolymerRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceNucleicAcidIxTok", "ix_Code");
DropIndex("dbo.SubstanceNucleicAcidIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceNucleicAcidRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubstanceIxTok", "ix_Code");
DropIndex("dbo.SubstanceIxRef", "ix_RefFhirId");
DropIndex("dbo.SubstanceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SubscriptionIxTok", "ix_Code");
DropIndex("dbo.SubscriptionIxRef", "ix_RefFhirId");
DropIndex("dbo.SubscriptionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.StructureMapIxTok", "ix_Code");
DropIndex("dbo.StructureMapIxRef", "ix_RefFhirId");
DropIndex("dbo.StructureMapRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.StructureDefinitionIxTok", "ix_Code");
DropIndex("dbo.StructureDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.StructureDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SpecimenIxTok", "ix_Code");
DropIndex("dbo.SpecimenIxRef", "ix_RefFhirId");
DropIndex("dbo.SpecimenRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SpecimenDefinitionIxTok", "ix_Code");
DropIndex("dbo.SpecimenDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.SpecimenDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SlotIxTok", "ix_Code");
DropIndex("dbo.SlotIxRef", "ix_RefFhirId");
DropIndex("dbo.SlotRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ServiceRequestIxTok", "ix_Code");
DropIndex("dbo.ServiceRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.ServiceRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.SearchParameterIxTok", "ix_Code");
DropIndex("dbo.SearchParameterIxRef", "ix_RefFhirId");
DropIndex("dbo.SearchParameterRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ScheduleIxTok", "ix_Code");
DropIndex("dbo.ScheduleIxRef", "ix_RefFhirId");
DropIndex("dbo.ScheduleRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.RiskEvidenceSynthesisIxTok", "ix_Code");
DropIndex("dbo.RiskEvidenceSynthesisIxRef", "ix_RefFhirId");
DropIndex("dbo.RiskEvidenceSynthesisRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.RiskAssessmentIxTok", "ix_Code");
DropIndex("dbo.RiskAssessmentIxRef", "ix_RefFhirId");
DropIndex("dbo.RiskAssessmentRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ResearchSubjectIxTok", "ix_Code");
DropIndex("dbo.ResearchSubjectIxRef", "ix_RefFhirId");
DropIndex("dbo.ResearchSubjectRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ResearchStudyIxTok", "ix_Code");
DropIndex("dbo.ResearchStudyIxRef", "ix_RefFhirId");
DropIndex("dbo.ResearchStudyRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ResearchElementDefinitionIxTok", "ix_Code");
DropIndex("dbo.ResearchElementDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ResearchElementDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ResearchDefinitionIxTok", "ix_Code");
DropIndex("dbo.ResearchDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ResearchDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.RequestGroupIxTok", "ix_Code");
DropIndex("dbo.RequestGroupIxRef", "ix_RefFhirId");
DropIndex("dbo.RequestGroupRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.RelatedPersonIxTok", "ix_Code");
DropIndex("dbo.RelatedPersonIxRef", "ix_RefFhirId");
DropIndex("dbo.RelatedPersonRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.QuestionnaireResponseIxTok", "ix_Code");
DropIndex("dbo.QuestionnaireResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.QuestionnaireResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.QuestionnaireIxTok", "ix_Code");
DropIndex("dbo.QuestionnaireIxRef", "ix_RefFhirId");
DropIndex("dbo.QuestionnaireRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ProvenanceIxTok", "ix_Code");
DropIndex("dbo.ProvenanceIxRef", "ix_RefFhirId");
DropIndex("dbo.ProvenanceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ProcedureIxTok", "ix_Code");
DropIndex("dbo.ProcedureIxRef", "ix_RefFhirId");
DropIndex("dbo.ProcedureRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PractitionerRoleIxTok", "ix_Code");
DropIndex("dbo.PractitionerRoleIxRef", "ix_RefFhirId");
DropIndex("dbo.PractitionerRoleRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PractitionerIxTok", "ix_Code");
DropIndex("dbo.PractitionerIxRef", "ix_RefFhirId");
DropIndex("dbo.PractitionerRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PlanDefinitionIxTok", "ix_Code");
DropIndex("dbo.PlanDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.PlanDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PersonIxTok", "ix_Code");
DropIndex("dbo.PersonIxRef", "ix_RefFhirId");
DropIndex("dbo.PersonRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PaymentReconciliationIxTok", "ix_Code");
DropIndex("dbo.PaymentReconciliationIxRef", "ix_RefFhirId");
DropIndex("dbo.PaymentReconciliationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PaymentNoticeIxTok", "ix_Code");
DropIndex("dbo.PaymentNoticeIxRef", "ix_RefFhirId");
DropIndex("dbo.PaymentNoticeRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.PatientIxTok", "ix_Code");
DropIndex("dbo.PatientIxRef", "ix_RefFhirId");
DropIndex("dbo.PatientRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ParametersIxTok", "ix_Code");
DropIndex("dbo.ParametersIxRef", "ix_RefFhirId");
DropIndex("dbo.ParametersRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.OrganizationIxTok", "ix_Code");
DropIndex("dbo.OrganizationIxRef", "ix_RefFhirId");
DropIndex("dbo.OrganizationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.OrganizationAffiliationIxTok", "ix_Code");
DropIndex("dbo.OrganizationAffiliationIxRef", "ix_RefFhirId");
DropIndex("dbo.OrganizationAffiliationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.OperationOutcomeIxTok", "ix_Code");
DropIndex("dbo.OperationOutcomeIxRef", "ix_RefFhirId");
DropIndex("dbo.OperationOutcomeRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.OperationDefinitionIxTok", "ix_Code");
DropIndex("dbo.OperationDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.OperationDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ObservationIxTok", "ix_Code");
DropIndex("dbo.ObservationIxRef", "ix_RefFhirId");
DropIndex("dbo.ObservationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ObservationDefinitionIxTok", "ix_Code");
DropIndex("dbo.ObservationDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ObservationDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.NutritionOrderIxTok", "ix_Code");
DropIndex("dbo.NutritionOrderIxRef", "ix_RefFhirId");
DropIndex("dbo.NutritionOrderRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.NamingSystemIxTok", "ix_Code");
DropIndex("dbo.NamingSystemIxRef", "ix_RefFhirId");
DropIndex("dbo.NamingSystemRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MolecularSequenceIxTok", "ix_Code");
DropIndex("dbo.MolecularSequenceIxRef", "ix_RefFhirId");
DropIndex("dbo.MolecularSequenceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MessageHeaderIxTok", "ix_Code");
DropIndex("dbo.MessageHeaderIxRef", "ix_RefFhirId");
DropIndex("dbo.MessageHeaderRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MessageDefinitionIxTok", "ix_Code");
DropIndex("dbo.MessageDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.MessageDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductUndesirableEffectIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductUndesirableEffectIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductUndesirableEffectRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductPharmaceuticalIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductPharmaceuticalIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductPharmaceuticalRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductPackagedIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductPackagedIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductPackagedRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductManufacturedIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductManufacturedIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductManufacturedRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductInteractionIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductInteractionIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductInteractionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductIngredientIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductIngredientIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductIngredientRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductIndicationIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductIndicationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductIndicationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductContraindicationIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductContraindicationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductContraindicationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicinalProductAuthorizationIxTok", "ix_Code");
DropIndex("dbo.MedicinalProductAuthorizationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicinalProductAuthorizationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationStatementIxTok", "ix_Code");
DropIndex("dbo.MedicationStatementIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationStatementRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationRequestIxTok", "ix_Code");
DropIndex("dbo.MedicationRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationIxTok", "ix_Code");
DropIndex("dbo.MedicationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationKnowledgeIxTok", "ix_Code");
DropIndex("dbo.MedicationKnowledgeIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationKnowledgeRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationDispenseIxTok", "ix_Code");
DropIndex("dbo.MedicationDispenseIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationDispenseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MedicationAdministrationIxTok", "ix_Code");
DropIndex("dbo.MedicationAdministrationIxRef", "ix_RefFhirId");
DropIndex("dbo.MedicationAdministrationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MediaIxTok", "ix_Code");
DropIndex("dbo.MediaIxRef", "ix_RefFhirId");
DropIndex("dbo.MediaRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MeasureReportIxTok", "ix_Code");
DropIndex("dbo.MeasureReportIxRef", "ix_RefFhirId");
DropIndex("dbo.MeasureReportRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.MeasureIxTok", "ix_Code");
DropIndex("dbo.MeasureIxRef", "ix_RefFhirId");
DropIndex("dbo.MeasureRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.LocationIxTok", "ix_Code");
DropIndex("dbo.LocationIxRef", "ix_RefFhirId");
DropIndex("dbo.LocationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ListIxTok", "ix_Code");
DropIndex("dbo.ListIxRef", "ix_RefFhirId");
DropIndex("dbo.ListRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.LinkageIxTok", "ix_Code");
DropIndex("dbo.LinkageIxRef", "ix_RefFhirId");
DropIndex("dbo.LinkageRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.LibraryIxTok", "ix_Code");
DropIndex("dbo.LibraryIxRef", "ix_RefFhirId");
DropIndex("dbo.LibraryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.InvoiceIxTok", "ix_Code");
DropIndex("dbo.InvoiceIxRef", "ix_RefFhirId");
DropIndex("dbo.InvoiceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.InsurancePlanIxTok", "ix_Code");
DropIndex("dbo.InsurancePlanIxRef", "ix_RefFhirId");
DropIndex("dbo.InsurancePlanRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImplementationGuideIxTok", "ix_Code");
DropIndex("dbo.ImplementationGuideIxRef", "ix_RefFhirId");
DropIndex("dbo.ImplementationGuideRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImmunizationRecommendationIxTok", "ix_Code");
DropIndex("dbo.ImmunizationRecommendationIxRef", "ix_RefFhirId");
DropIndex("dbo.ImmunizationRecommendationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImmunizationIxTok", "ix_Code");
DropIndex("dbo.ImmunizationIxRef", "ix_RefFhirId");
DropIndex("dbo.ImmunizationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImmunizationEvaluationIxTok", "ix_Code");
DropIndex("dbo.ImmunizationEvaluationIxRef", "ix_RefFhirId");
DropIndex("dbo.ImmunizationEvaluationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ImagingStudyIxTok", "ix_Code");
DropIndex("dbo.ImagingStudyIxRef", "ix_RefFhirId");
DropIndex("dbo.ImagingStudyRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.HealthcareServiceIxTok", "ix_Code");
DropIndex("dbo.HealthcareServiceIxRef", "ix_RefFhirId");
DropIndex("dbo.HealthcareServiceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.GuidanceResponseIxTok", "ix_Code");
DropIndex("dbo.GuidanceResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.GuidanceResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.GroupIxTok", "ix_Code");
DropIndex("dbo.GroupIxRef", "ix_RefFhirId");
DropIndex("dbo.GroupRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.GraphDefinitionIxTok", "ix_Code");
DropIndex("dbo.GraphDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.GraphDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.GoalIxTok", "ix_Code");
DropIndex("dbo.GoalIxRef", "ix_RefFhirId");
DropIndex("dbo.GoalRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.FlagIxTok", "ix_Code");
DropIndex("dbo.FlagIxRef", "ix_RefFhirId");
DropIndex("dbo.FlagRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.FamilyMemberHistoryIxTok", "ix_Code");
DropIndex("dbo.FamilyMemberHistoryIxRef", "ix_RefFhirId");
DropIndex("dbo.FamilyMemberHistoryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ExplanationOfBenefitIxTok", "ix_Code");
DropIndex("dbo.ExplanationOfBenefitIxRef", "ix_RefFhirId");
DropIndex("dbo.ExplanationOfBenefitRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ExampleScenarioIxTok", "ix_Code");
DropIndex("dbo.ExampleScenarioIxRef", "ix_RefFhirId");
DropIndex("dbo.ExampleScenarioRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EvidenceVariableIxTok", "ix_Code");
DropIndex("dbo.EvidenceVariableIxRef", "ix_RefFhirId");
DropIndex("dbo.EvidenceVariableRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EvidenceIxTok", "ix_Code");
DropIndex("dbo.EvidenceIxRef", "ix_RefFhirId");
DropIndex("dbo.EvidenceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EventDefinitionIxTok", "ix_Code");
DropIndex("dbo.EventDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.EventDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EpisodeOfCareIxTok", "ix_Code");
DropIndex("dbo.EpisodeOfCareIxRef", "ix_RefFhirId");
DropIndex("dbo.EpisodeOfCareRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EnrollmentResponseIxTok", "ix_Code");
DropIndex("dbo.EnrollmentResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.EnrollmentResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EnrollmentRequestIxTok", "ix_Code");
DropIndex("dbo.EnrollmentRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.EnrollmentRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EndpointIxTok", "ix_Code");
DropIndex("dbo.EndpointIxRef", "ix_RefFhirId");
DropIndex("dbo.EndpointRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EncounterIxTok", "ix_Code");
DropIndex("dbo.EncounterIxRef", "ix_RefFhirId");
DropIndex("dbo.EncounterRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.EffectEvidenceSynthesisIxTok", "ix_Code");
DropIndex("dbo.EffectEvidenceSynthesisIxRef", "ix_RefFhirId");
DropIndex("dbo.EffectEvidenceSynthesisRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DocumentReferenceIxTok", "ix_Code");
DropIndex("dbo.DocumentReferenceIxRef", "ix_RefFhirId");
DropIndex("dbo.DocumentReferenceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DocumentManifestIxTok", "ix_Code");
DropIndex("dbo.DocumentManifestIxRef", "ix_RefFhirId");
DropIndex("dbo.DocumentManifestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DiagnosticReportIxTok", "ix_Code");
DropIndex("dbo.DiagnosticReportIxRef", "ix_RefFhirId");
DropIndex("dbo.DiagnosticReportRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceUseStatementIxTok", "ix_Code");
DropIndex("dbo.DeviceUseStatementIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceUseStatementRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceRequestIxTok", "ix_Code");
DropIndex("dbo.DeviceRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceMetricIxTok", "ix_Code");
DropIndex("dbo.DeviceMetricIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceMetricRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceIxTok", "ix_Code");
DropIndex("dbo.DeviceIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DeviceDefinitionIxTok", "ix_Code");
DropIndex("dbo.DeviceDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.DeviceDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.DetectedIssueIxTok", "ix_Code");
DropIndex("dbo.DetectedIssueIxRef", "ix_RefFhirId");
DropIndex("dbo.DetectedIssueRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CoverageIxTok", "ix_Code");
DropIndex("dbo.CoverageIxRef", "ix_RefFhirId");
DropIndex("dbo.CoverageRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CoverageEligibilityResponseIxTok", "ix_Code");
DropIndex("dbo.CoverageEligibilityResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.CoverageEligibilityResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CoverageEligibilityRequestIxTok", "ix_Code");
DropIndex("dbo.CoverageEligibilityRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.CoverageEligibilityRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ContractIxTok", "ix_Code");
DropIndex("dbo.ContractIxRef", "ix_RefFhirId");
DropIndex("dbo.ContractRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ConsentIxTok", "ix_Code");
DropIndex("dbo.ConsentIxRef", "ix_RefFhirId");
DropIndex("dbo.ConsentRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ConditionIxTok", "ix_Code");
DropIndex("dbo.ConditionIxRef", "ix_RefFhirId");
DropIndex("dbo.ConditionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ConceptMapIxTok", "ix_Code");
DropIndex("dbo.ConceptMapIxRef", "ix_RefFhirId");
DropIndex("dbo.ConceptMapRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CompositionIxTok", "ix_Code");
DropIndex("dbo.CompositionIxRef", "ix_RefFhirId");
DropIndex("dbo.CompositionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CompartmentDefinitionIxTok", "ix_Code");
DropIndex("dbo.CompartmentDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.CompartmentDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CommunicationRequestIxTok", "ix_Code");
DropIndex("dbo.CommunicationRequestIxRef", "ix_RefFhirId");
DropIndex("dbo.CommunicationRequestRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CommunicationIxTok", "ix_Code");
DropIndex("dbo.CommunicationIxRef", "ix_RefFhirId");
DropIndex("dbo.CommunicationRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CodeSystemIxTok", "ix_Code");
DropIndex("dbo.CodeSystemIxRef", "ix_RefFhirId");
DropIndex("dbo.CodeSystemRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ClinicalImpressionIxTok", "ix_Code");
DropIndex("dbo.ClinicalImpressionIxRef", "ix_RefFhirId");
DropIndex("dbo.ClinicalImpressionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ClaimResponseIxTok", "ix_Code");
DropIndex("dbo.ClaimResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.ClaimResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ClaimIxTok", "ix_Code");
DropIndex("dbo.ClaimIxRef", "ix_RefFhirId");
DropIndex("dbo.ClaimRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ChargeItemIxTok", "ix_Code");
DropIndex("dbo.ChargeItemIxRef", "ix_RefFhirId");
DropIndex("dbo.ChargeItemRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ChargeItemDefinitionIxTok", "ix_Code");
DropIndex("dbo.ChargeItemDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ChargeItemDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CatalogEntryIxTok", "ix_Code");
DropIndex("dbo.CatalogEntryIxRef", "ix_RefFhirId");
DropIndex("dbo.CatalogEntryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CareTeamIxTok", "ix_Code");
DropIndex("dbo.CareTeamIxRef", "ix_RefFhirId");
DropIndex("dbo.CareTeamRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CarePlanIxTok", "ix_Code");
DropIndex("dbo.CarePlanIxRef", "ix_RefFhirId");
DropIndex("dbo.CarePlanRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.CapabilityStatementIxTok", "ix_Code");
DropIndex("dbo.CapabilityStatementIxRef", "ix_RefFhirId");
DropIndex("dbo.CapabilityStatementRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BundleIxTok", "ix_Code");
DropIndex("dbo.BundleIxRef", "ix_RefFhirId");
DropIndex("dbo.BundleRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BodyStructureIxTok", "ix_Code");
DropIndex("dbo.BodyStructureIxRef", "ix_RefFhirId");
DropIndex("dbo.BodyStructureRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BiologicallyDerivedProductIxTok", "ix_Code");
DropIndex("dbo.BiologicallyDerivedProductIxRef", "ix_RefFhirId");
DropIndex("dbo.BiologicallyDerivedProductRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BinaryIxTok", "ix_Code");
DropIndex("dbo.BinaryIxRef", "ix_RefFhirId");
DropIndex("dbo.BinaryRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.BasicIxTok", "ix_Code");
DropIndex("dbo.BasicIxRef", "ix_RefFhirId");
DropIndex("dbo.BasicRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AuditEventIxTok", "ix_Code");
DropIndex("dbo.AuditEventIxRef", "ix_RefFhirId");
DropIndex("dbo.AuditEventRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AppointmentResponseIxTok", "ix_Code");
DropIndex("dbo.AppointmentResponseIxRef", "ix_RefFhirId");
DropIndex("dbo.AppointmentResponseRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AppointmentIxTok", "ix_Code");
DropIndex("dbo.AppointmentIxRef", "ix_RefFhirId");
DropIndex("dbo.AppointmentRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AllergyIntoleranceIxTok", "ix_Code");
DropIndex("dbo.AllergyIntoleranceIxRef", "ix_RefFhirId");
DropIndex("dbo.AllergyIntoleranceRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AdverseEventIxTok", "ix_Code");
DropIndex("dbo.AdverseEventIxRef", "ix_RefFhirId");
DropIndex("dbo.AdverseEventRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.ActivityDefinitionIxTok", "ix_Code");
DropIndex("dbo.ActivityDefinitionIxRef", "ix_RefFhirId");
DropIndex("dbo.ActivityDefinitionRes", "uq_FhirIdAndVersionId");
DropIndex("dbo.AccountRes", "uq_FhirIdAndVersionId");
AlterColumn("dbo.AccountIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AccountIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AccountIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VisionPrescriptionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VisionPrescriptionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VisionPrescriptionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VisionPrescriptionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VisionPrescriptionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VerificationResultIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VerificationResultIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VerificationResultIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VerificationResultRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.VerificationResultRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ValueSetIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ValueSetIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ValueSetIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ValueSetRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ValueSetRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestScriptIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestScriptIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestScriptIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestScriptRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestScriptRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestReportIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestReportIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestReportIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestReportRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TestReportRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TerminologyCapabilitiesIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TerminologyCapabilitiesIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TerminologyCapabilitiesIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TerminologyCapabilitiesRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TerminologyCapabilitiesRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TaskIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TaskIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TaskIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TaskRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.TaskRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyDeliveryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyDeliveryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyDeliveryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyDeliveryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SupplyDeliveryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSpecificationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSpecificationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSpecificationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSpecificationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSpecificationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSourceMaterialIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSourceMaterialIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSourceMaterialIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSourceMaterialRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceSourceMaterialRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceReferenceInformationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceReferenceInformationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceReferenceInformationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceReferenceInformationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceReferenceInformationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceProteinIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceProteinIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceProteinIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceProteinRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceProteinRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstancePolymerIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstancePolymerIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstancePolymerIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstancePolymerRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstancePolymerRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceNucleicAcidIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceNucleicAcidIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceNucleicAcidIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceNucleicAcidRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceNucleicAcidRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubstanceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubscriptionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubscriptionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubscriptionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubscriptionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SubscriptionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureMapIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureMapIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureMapIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureMapRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureMapRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.StructureDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SpecimenDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SlotIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SlotIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SlotIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SlotRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SlotRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ServiceRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ServiceRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ServiceRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ServiceRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ServiceRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SearchParameterIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SearchParameterIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SearchParameterIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SearchParameterRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.SearchParameterRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ScheduleIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ScheduleIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ScheduleIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ScheduleRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ScheduleRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskEvidenceSynthesisRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskAssessmentIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskAssessmentIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskAssessmentIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskAssessmentRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RiskAssessmentRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchSubjectIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchSubjectIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchSubjectIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchSubjectRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchSubjectRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchStudyIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchStudyIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchStudyIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchStudyRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchStudyRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchElementDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchElementDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchElementDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchElementDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchElementDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ResearchDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RequestGroupIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RequestGroupIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RequestGroupIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RequestGroupRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RequestGroupRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RelatedPersonIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RelatedPersonIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RelatedPersonIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RelatedPersonRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.RelatedPersonRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.QuestionnaireRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProvenanceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProvenanceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProvenanceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProvenanceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProvenanceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProcedureIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProcedureIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProcedureIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProcedureRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ProcedureRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerRoleIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerRoleIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerRoleIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerRoleRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerRoleRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PractitionerRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PlanDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PlanDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PlanDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PlanDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PlanDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PersonIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PersonIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PersonIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PersonRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PersonRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentReconciliationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentReconciliationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentReconciliationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentReconciliationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentReconciliationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentNoticeIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentNoticeIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentNoticeIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentNoticeRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PaymentNoticeRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PatientIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PatientIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PatientIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PatientRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.PatientRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ParametersIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ParametersIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ParametersIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ParametersRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ParametersRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationAffiliationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationAffiliationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationAffiliationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationAffiliationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OrganizationAffiliationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationOutcomeIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationOutcomeIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationOutcomeIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationOutcomeRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationOutcomeRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.OperationDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ObservationDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NutritionOrderIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NutritionOrderIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NutritionOrderIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NutritionOrderRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NutritionOrderRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NamingSystemIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NamingSystemIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NamingSystemIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NamingSystemRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.NamingSystemRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MolecularSequenceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MolecularSequenceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MolecularSequenceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MolecularSequenceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MolecularSequenceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageHeaderIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageHeaderIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageHeaderIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageHeaderRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageHeaderRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MessageDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductUndesirableEffectRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPharmaceuticalRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPackagedIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPackagedIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPackagedIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPackagedRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductPackagedRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductManufacturedIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductManufacturedIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductManufacturedIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductManufacturedRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductManufacturedRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductInteractionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductInteractionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductInteractionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductInteractionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductInteractionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIngredientIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIngredientIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIngredientIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIngredientRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIngredientRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIndicationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIndicationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIndicationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIndicationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductIndicationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductContraindicationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductContraindicationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductContraindicationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductContraindicationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductContraindicationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicinalProductAuthorizationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationStatementIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationStatementIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationStatementIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationStatementRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationStatementRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationKnowledgeIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationKnowledgeIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationKnowledgeIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationKnowledgeRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationKnowledgeRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationDispenseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationDispenseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationDispenseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationDispenseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationDispenseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationAdministrationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationAdministrationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationAdministrationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationAdministrationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MedicationAdministrationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MediaIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MediaIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MediaIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MediaRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MediaRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureReportIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureReportIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureReportIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureReportRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureReportRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.MeasureRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LocationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LocationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LocationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LocationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LocationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ListIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ListIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ListIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ListRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ListRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LinkageIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LinkageIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LinkageIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LinkageRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LinkageRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LibraryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LibraryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LibraryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LibraryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.LibraryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InvoiceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InvoiceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InvoiceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InvoiceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InvoiceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InsurancePlanIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InsurancePlanIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InsurancePlanIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InsurancePlanRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.InsurancePlanRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImplementationGuideIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImplementationGuideIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImplementationGuideIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImplementationGuideRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImplementationGuideRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationRecommendationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationRecommendationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationRecommendationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationRecommendationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationRecommendationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationEvaluationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationEvaluationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationEvaluationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationEvaluationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImmunizationEvaluationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImagingStudyIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImagingStudyIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImagingStudyIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImagingStudyRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ImagingStudyRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.HealthcareServiceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.HealthcareServiceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.HealthcareServiceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.HealthcareServiceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.HealthcareServiceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GuidanceResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GuidanceResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GuidanceResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GuidanceResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GuidanceResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GroupIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GroupIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GroupIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GroupRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GroupRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GraphDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GraphDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GraphDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GraphDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GraphDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GoalIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GoalIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GoalIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GoalRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.GoalRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FlagIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FlagIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FlagIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FlagRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FlagRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FamilyMemberHistoryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FamilyMemberHistoryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FamilyMemberHistoryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FamilyMemberHistoryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.FamilyMemberHistoryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExplanationOfBenefitIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExplanationOfBenefitIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExplanationOfBenefitIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExplanationOfBenefitRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExplanationOfBenefitRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExampleScenarioIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExampleScenarioIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExampleScenarioIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExampleScenarioRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ExampleScenarioRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceVariableIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceVariableIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceVariableIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceVariableRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceVariableRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EvidenceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EventDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EventDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EventDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EventDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EventDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EpisodeOfCareIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EpisodeOfCareIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EpisodeOfCareIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EpisodeOfCareRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EpisodeOfCareRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EnrollmentRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EndpointIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EndpointIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EndpointIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EndpointRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EndpointRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EncounterIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EncounterIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EncounterIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EncounterRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EncounterRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.EffectEvidenceSynthesisRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentReferenceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentReferenceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentReferenceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentReferenceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentReferenceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentManifestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentManifestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentManifestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentManifestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DocumentManifestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DiagnosticReportIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DiagnosticReportIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DiagnosticReportIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DiagnosticReportRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DiagnosticReportRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceUseStatementIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceUseStatementIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceUseStatementIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceUseStatementRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceUseStatementRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceMetricIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceMetricIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceMetricIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceMetricRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceMetricRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DeviceDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DetectedIssueIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DetectedIssueIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DetectedIssueIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DetectedIssueRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.DetectedIssueRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CoverageEligibilityRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ContractIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ContractIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ContractIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ContractRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ContractRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConsentIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConsentIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConsentIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConsentRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConsentRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConditionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConditionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConditionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConditionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConditionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConceptMapIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConceptMapIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConceptMapIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConceptMapRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ConceptMapRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompositionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompositionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompositionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompositionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompositionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompartmentDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompartmentDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompartmentDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompartmentDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CompartmentDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationRequestIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationRequestIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationRequestIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationRequestRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationRequestRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CommunicationRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CodeSystemIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CodeSystemIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CodeSystemIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CodeSystemRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CodeSystemRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClinicalImpressionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClinicalImpressionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClinicalImpressionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClinicalImpressionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClinicalImpressionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ClaimRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ChargeItemDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CatalogEntryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CatalogEntryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CatalogEntryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CatalogEntryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CatalogEntryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CareTeamIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CareTeamIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CareTeamIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CareTeamRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CareTeamRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CarePlanIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CarePlanIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CarePlanIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CarePlanRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CarePlanRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CapabilityStatementIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CapabilityStatementIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CapabilityStatementIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CapabilityStatementRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.CapabilityStatementRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BundleIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BundleIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BundleIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BundleRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BundleRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BodyStructureIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BodyStructureIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BodyStructureIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BodyStructureRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BodyStructureRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BiologicallyDerivedProductIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BiologicallyDerivedProductIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BiologicallyDerivedProductIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BiologicallyDerivedProductRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BiologicallyDerivedProductRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BinaryIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BinaryIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BinaryIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BinaryRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BinaryRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BasicIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BasicIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BasicIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BasicRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.BasicRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AuditEventIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AuditEventIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AuditEventIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AuditEventRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AuditEventRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentResponseIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentResponseIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentResponseIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentResponseRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentResponseRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AppointmentRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AllergyIntoleranceIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AllergyIntoleranceIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AllergyIntoleranceIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AllergyIntoleranceRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AllergyIntoleranceRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AdverseEventIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AdverseEventIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AdverseEventIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AdverseEventRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AdverseEventRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ActivityDefinitionIxTok", "Code", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ActivityDefinitionIxRef", "ReferenceVersionId", c => c.String(maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ActivityDefinitionIxRef", "ReferenceFhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ActivityDefinitionRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.ActivityDefinitionRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AccountRes", "VersionId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
AlterColumn("dbo.AccountRes", "FhirId", c => c.String(nullable: false, maxLength: 128,
annotations: new Dictionary<string, AnnotationValues>
{
{
"CaseSensitive",
new AnnotationValues(oldValue: "True", newValue: null)
},
}));
CreateIndex("dbo.AccountIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AccountIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.VisionPrescriptionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.VisionPrescriptionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.VisionPrescriptionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.VerificationResultIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.VerificationResultIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.VerificationResultRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ValueSetIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ValueSetIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ValueSetRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.TestScriptIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.TestScriptIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.TestScriptRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.TestReportIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.TestReportIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.TestReportRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.TerminologyCapabilitiesIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.TerminologyCapabilitiesIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.TerminologyCapabilitiesRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.TaskIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.TaskIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.TaskRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SupplyRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SupplyRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SupplyRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SupplyDeliveryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SupplyDeliveryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SupplyDeliveryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceSpecificationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceSpecificationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceSpecificationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceSourceMaterialIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceSourceMaterialIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceSourceMaterialRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceReferenceInformationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceReferenceInformationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceReferenceInformationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceProteinIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceProteinIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceProteinRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstancePolymerIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstancePolymerIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstancePolymerRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceNucleicAcidIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceNucleicAcidIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceNucleicAcidRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubstanceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubstanceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubstanceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SubscriptionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SubscriptionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SubscriptionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.StructureMapIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.StructureMapIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.StructureMapRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.StructureDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.StructureDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.StructureDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SpecimenIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SpecimenIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SpecimenRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SpecimenDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SpecimenDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SpecimenDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SlotIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SlotIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SlotRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ServiceRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ServiceRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ServiceRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.SearchParameterIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.SearchParameterIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.SearchParameterRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ScheduleIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ScheduleIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ScheduleRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.RiskEvidenceSynthesisIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.RiskEvidenceSynthesisIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.RiskEvidenceSynthesisRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.RiskAssessmentIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.RiskAssessmentIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.RiskAssessmentRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ResearchSubjectIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ResearchSubjectIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ResearchSubjectRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ResearchStudyIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ResearchStudyIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ResearchStudyRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ResearchElementDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ResearchElementDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ResearchElementDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ResearchDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ResearchDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ResearchDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.RequestGroupIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.RequestGroupIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.RequestGroupRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.RelatedPersonIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.RelatedPersonIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.RelatedPersonRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.QuestionnaireResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.QuestionnaireResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.QuestionnaireResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.QuestionnaireIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.QuestionnaireIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.QuestionnaireRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ProvenanceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ProvenanceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ProvenanceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ProcedureIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ProcedureIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ProcedureRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PractitionerRoleIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PractitionerRoleIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PractitionerRoleRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PractitionerIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PractitionerIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PractitionerRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PlanDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PlanDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PlanDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PersonIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PersonIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PersonRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PaymentReconciliationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PaymentReconciliationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PaymentReconciliationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PaymentNoticeIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PaymentNoticeIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PaymentNoticeRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.PatientIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.PatientIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.PatientRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ParametersIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ParametersIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ParametersRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.OrganizationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.OrganizationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.OrganizationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.OrganizationAffiliationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.OrganizationAffiliationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.OrganizationAffiliationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.OperationOutcomeIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.OperationOutcomeIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.OperationOutcomeRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.OperationDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.OperationDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.OperationDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ObservationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ObservationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ObservationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ObservationDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ObservationDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ObservationDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.NutritionOrderIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.NutritionOrderIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.NutritionOrderRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.NamingSystemIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.NamingSystemIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.NamingSystemRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MolecularSequenceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MolecularSequenceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MolecularSequenceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MessageHeaderIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MessageHeaderIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MessageHeaderRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MessageDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MessageDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MessageDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductUndesirableEffectIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductUndesirableEffectIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductUndesirableEffectRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductPharmaceuticalIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductPharmaceuticalIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductPharmaceuticalRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductPackagedIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductPackagedIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductPackagedRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductManufacturedIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductManufacturedIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductManufacturedRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductInteractionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductInteractionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductInteractionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductIngredientIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductIngredientIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductIngredientRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductIndicationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductIndicationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductIndicationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductContraindicationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductContraindicationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductContraindicationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicinalProductAuthorizationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicinalProductAuthorizationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicinalProductAuthorizationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationStatementIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationStatementIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationStatementRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationKnowledgeIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationKnowledgeIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationKnowledgeRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationDispenseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationDispenseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationDispenseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MedicationAdministrationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MedicationAdministrationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MedicationAdministrationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MediaIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MediaIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MediaRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MeasureReportIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MeasureReportIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MeasureReportRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.MeasureIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.MeasureIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.MeasureRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.LocationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.LocationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.LocationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ListIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ListIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ListRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.LinkageIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.LinkageIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.LinkageRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.LibraryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.LibraryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.LibraryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.InvoiceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.InvoiceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.InvoiceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.InsurancePlanIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.InsurancePlanIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.InsurancePlanRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImplementationGuideIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImplementationGuideIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImplementationGuideRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImmunizationRecommendationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImmunizationRecommendationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImmunizationRecommendationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImmunizationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImmunizationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImmunizationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImmunizationEvaluationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImmunizationEvaluationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImmunizationEvaluationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ImagingStudyIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ImagingStudyIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ImagingStudyRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.HealthcareServiceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.HealthcareServiceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.HealthcareServiceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.GuidanceResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.GuidanceResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.GuidanceResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.GroupIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.GroupIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.GroupRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.GraphDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.GraphDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.GraphDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.GoalIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.GoalIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.GoalRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.FlagIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.FlagIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.FlagRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.FamilyMemberHistoryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.FamilyMemberHistoryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.FamilyMemberHistoryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ExplanationOfBenefitIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ExplanationOfBenefitIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ExplanationOfBenefitRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ExampleScenarioIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ExampleScenarioIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ExampleScenarioRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EvidenceVariableIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EvidenceVariableIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EvidenceVariableRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EvidenceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EvidenceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EvidenceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EventDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EventDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EventDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EpisodeOfCareIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EpisodeOfCareIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EpisodeOfCareRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EnrollmentResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EnrollmentResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EnrollmentResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EnrollmentRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EnrollmentRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EnrollmentRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EndpointIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EndpointIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EndpointRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EncounterIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EncounterIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EncounterRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.EffectEvidenceSynthesisIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.EffectEvidenceSynthesisIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.EffectEvidenceSynthesisRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DocumentReferenceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DocumentReferenceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DocumentReferenceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DocumentManifestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DocumentManifestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DocumentManifestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DiagnosticReportIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DiagnosticReportIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DiagnosticReportRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceUseStatementIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceUseStatementIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceUseStatementRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceMetricIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceMetricIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceMetricRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DeviceDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DeviceDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DeviceDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.DetectedIssueIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.DetectedIssueIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.DetectedIssueRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CoverageIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CoverageIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CoverageRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CoverageEligibilityResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CoverageEligibilityResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CoverageEligibilityResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CoverageEligibilityRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CoverageEligibilityRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CoverageEligibilityRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ContractIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ContractIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ContractRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ConsentIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ConsentIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ConsentRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ConditionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ConditionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ConditionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ConceptMapIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ConceptMapIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ConceptMapRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CompositionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CompositionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CompositionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CompartmentDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CompartmentDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CompartmentDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CommunicationRequestIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CommunicationRequestIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CommunicationRequestRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CommunicationIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CommunicationIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CommunicationRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CodeSystemIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CodeSystemIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CodeSystemRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ClinicalImpressionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ClinicalImpressionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ClinicalImpressionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ClaimResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ClaimResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ClaimResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ClaimIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ClaimIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ClaimRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ChargeItemIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ChargeItemIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ChargeItemRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ChargeItemDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ChargeItemDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ChargeItemDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CatalogEntryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CatalogEntryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CatalogEntryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CareTeamIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CareTeamIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CareTeamRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CarePlanIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CarePlanIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CarePlanRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.CapabilityStatementIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.CapabilityStatementIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.CapabilityStatementRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BundleIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BundleIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BundleRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BodyStructureIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BodyStructureIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BodyStructureRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BiologicallyDerivedProductIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BiologicallyDerivedProductIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BiologicallyDerivedProductRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BinaryIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BinaryIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BinaryRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.BasicIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.BasicIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.BasicRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AuditEventIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AuditEventIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AuditEventRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AppointmentResponseIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AppointmentResponseIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AppointmentResponseRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AppointmentIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AppointmentIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AppointmentRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AllergyIntoleranceIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AllergyIntoleranceIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AllergyIntoleranceRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AdverseEventIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.AdverseEventIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.AdverseEventRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.ActivityDefinitionIxTok", "Code", name: "ix_Code");
CreateIndex("dbo.ActivityDefinitionIxRef", "ReferenceFhirId", name: "ix_RefFhirId");
CreateIndex("dbo.ActivityDefinitionRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
CreateIndex("dbo.AccountRes", new[] { "FhirId", "VersionId" }, unique: true, name: "uq_FhirIdAndVersionId");
}
}
}
| 52.26117 | 146 | 0.498003 | [
"BSD-3-Clause"
] | nwisbeta/Pyro | Pyro.DataLayer/MigrationsMicrosoftSQLServer/201904230511080_CaseSensitive.cs | 702,965 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// 有关程序集的常规信息是通过以下项进行控制的
// 控制。更改这些特性值可修改
// 与程序集关联的信息。
[assembly: AssemblyTitle("AspNet.Auth.Tests")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("AspNet.Auth.Tests")]
[assembly: AssemblyCopyright("版权所有(C) 2020")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// 将 ComVisible 设置为 false 将使此程序集中的类型
// 对 COM 组件不可见。如果需要
// 从 COM 访问此程序集中的某个类型，请针对该类型将 ComVisible 特性设置为 true。
[assembly: ComVisible(false)]
// 如果此项目向 COM 公开，则下列 GUID 用于 typelib 的 ID
[assembly: Guid("cd0ef44a-816c-48cc-908b-4792e3e6dae2")]
// 程序集的版本信息由下列四个值组成:
//
// 主版本
// 次版本
// 内部版本号
// 修订版本
//
// 你可以指定所有值，也可以让修订版本和内部版本号采用默认值，
// 方法是按如下所示使用 "*":
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
| 25.805556 | 56 | 0.723358 | [
"Apache-2.0"
] | WebDesigns07/AspNet.WebApi | src/AspNet.Auth.Tests/Properties/AssemblyInfo.cs | 1,301 | C# |
// *** WARNING: this file was generated by pulumigen. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Pulumi.Serialization;
namespace Pulumi.Kubernetes.FlowControl.V1Beta2
{
/// <summary>
/// FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher".
/// </summary>
[KubernetesResourceType("kubernetes:flowcontrol.apiserver.k8s.io/v1beta2:FlowSchema")]
public partial class FlowSchema : KubernetesResource
{
/// <summary>
/// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
/// </summary>
[Output("apiVersion")]
public Output<string> ApiVersion { get; private set; } = null!;
/// <summary>
/// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
/// </summary>
[Output("kind")]
public Output<string> Kind { get; private set; } = null!;
/// <summary>
/// `metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
/// </summary>
[Output("metadata")]
public Output<Pulumi.Kubernetes.Types.Outputs.Meta.V1.ObjectMeta> Metadata { get; private set; } = null!;
/// <summary>
/// `spec` is the specification of the desired behavior of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
/// </summary>
[Output("spec")]
public Output<Pulumi.Kubernetes.Types.Outputs.FlowControl.V1Beta2.FlowSchemaSpec> Spec { get; private set; } = null!;
/// <summary>
/// `status` is the current status of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
/// </summary>
[Output("status")]
public Output<Pulumi.Kubernetes.Types.Outputs.FlowControl.V1Beta2.FlowSchemaStatus> Status { get; private set; } = null!;
/// <summary>
/// Create a FlowSchema resource with the given unique name, arguments, and options.
/// </summary>
///
/// <param name="name">The unique name of the resource</param>
/// <param name="args">The arguments used to populate this resource's properties</param>
/// <param name="options">A bag of options that control this resource's behavior</param>
public FlowSchema(string name, Pulumi.Kubernetes.Types.Inputs.FlowControl.V1Beta2.FlowSchemaArgs? args = null, CustomResourceOptions? options = null)
: base("kubernetes:flowcontrol.apiserver.k8s.io/v1beta2:FlowSchema", name, MakeArgs(args), MakeResourceOptions(options, ""))
{
}
internal FlowSchema(string name, ImmutableDictionary<string, object?> dictionary, CustomResourceOptions? options = null)
: base("kubernetes:flowcontrol.apiserver.k8s.io/v1beta2:FlowSchema", name, new DictionaryResourceArgs(dictionary), MakeResourceOptions(options, ""))
{
}
private FlowSchema(string name, Input<string> id, CustomResourceOptions? options = null)
: base("kubernetes:flowcontrol.apiserver.k8s.io/v1beta2:FlowSchema", name, null, MakeResourceOptions(options, id))
{
}
private static Pulumi.Kubernetes.Types.Inputs.FlowControl.V1Beta2.FlowSchemaArgs? MakeArgs(Pulumi.Kubernetes.Types.Inputs.FlowControl.V1Beta2.FlowSchemaArgs? args)
{
args ??= new Pulumi.Kubernetes.Types.Inputs.FlowControl.V1Beta2.FlowSchemaArgs();
args.ApiVersion = "flowcontrol.apiserver.k8s.io/v1beta2";
args.Kind = "FlowSchema";
return args;
}
private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
{
var defaultOptions = new CustomResourceOptions
{
Version = Utilities.Version,
Aliases =
{
new Pulumi.Alias { Type = "kubernetes:flowcontrol.apiserver.k8s.io/v1alpha1:FlowSchema"},
new Pulumi.Alias { Type = "kubernetes:flowcontrol.apiserver.k8s.io/v1beta1:FlowSchema"},
},
};
var merged = CustomResourceOptions.Merge(defaultOptions, options);
// Override the ID if one was specified for consistency with other language SDKs.
merged.Id = id ?? merged.Id;
return merged;
}
/// <summary>
/// Get an existing FlowSchema resource's state with the given name, ID, and optional extra
/// properties used to qualify the lookup.
/// </summary>
///
/// <param name="name">The unique name of the resulting resource.</param>
/// <param name="id">The unique provider ID of the resource to lookup.</param>
/// <param name="options">A bag of options that control this resource's behavior</param>
public static FlowSchema Get(string name, Input<string> id, CustomResourceOptions? options = null)
{
return new FlowSchema(name, id, options);
}
}
}
namespace Pulumi.Kubernetes.Types.Inputs.FlowControl.V1Beta2
{
public class FlowSchemaArgs : Pulumi.ResourceArgs
{
/// <summary>
/// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
/// </summary>
[Input("apiVersion")]
public Input<string>? ApiVersion { get; set; }
/// <summary>
/// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
/// </summary>
[Input("kind")]
public Input<string>? Kind { get; set; }
/// <summary>
/// `metadata` is the standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
/// </summary>
[Input("metadata")]
public Input<Pulumi.Kubernetes.Types.Inputs.Meta.V1.ObjectMetaArgs>? Metadata { get; set; }
/// <summary>
/// `spec` is the specification of the desired behavior of a FlowSchema. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
/// </summary>
[Input("spec")]
public Input<Pulumi.Kubernetes.Types.Inputs.FlowControl.V1Beta2.FlowSchemaSpecArgs>? Spec { get; set; }
public FlowSchemaArgs()
{
}
}
}
| 54.084507 | 302 | 0.668359 | [
"Apache-2.0"
] | Threpio/pulumi-kubernetes | sdk/dotnet/FlowControl/V1Beta2/FlowSchema.cs | 7,680 | C# |
using System;
using System.Globalization;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using System.Web;
using System.Web.Mvc;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.Owin;
using Microsoft.Owin.Security;
using MVCTestProject.Models;
namespace MVCTestProject.Controllers
{
[Authorize]
public class AccountController : Controller
{
private ApplicationSignInManager _signInManager;
private ApplicationUserManager _userManager;
public AccountController()
{
}
public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager )
{
UserManager = userManager;
SignInManager = signInManager;
}
public ApplicationSignInManager SignInManager
{
get
{
return _signInManager ?? HttpContext.GetOwinContext().Get<ApplicationSignInManager>();
}
private set
{
_signInManager = value;
}
}
public ApplicationUserManager UserManager
{
get
{
return _userManager ?? HttpContext.GetOwinContext().GetUserManager<ApplicationUserManager>();
}
private set
{
_userManager = value;
}
}
//
// GET: /Account/Login
[AllowAnonymous]
public ActionResult Login(string returnUrl)
{
ViewBag.ReturnUrl = returnUrl;
return View();
}
//
// POST: /Account/Login
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
}
//
// GET: /Account/VerifyCode
[AllowAnonymous]
public async Task<ActionResult> VerifyCode(string provider, string returnUrl, bool rememberMe)
{
// Require that the user has already logged in via username/password or external login
if (!await SignInManager.HasBeenVerifiedAsync())
{
return View("Error");
}
return View(new VerifyCodeViewModel { Provider = provider, ReturnUrl = returnUrl, RememberMe = rememberMe });
}
//
// POST: /Account/VerifyCode
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> VerifyCode(VerifyCodeViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
// The following code protects for brute force attacks against the two factor codes.
// If a user enters incorrect codes for a specified amount of time then the user account
// will be locked out for a specified amount of time.
// You can configure the account lockout settings in IdentityConfig
var result = await SignInManager.TwoFactorSignInAsync(model.Provider, model.Code, isPersistent: model.RememberMe, rememberBrowser: model.RememberBrowser);
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(model.ReturnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid code.");
return View(model);
}
}
//
// GET: /Account/Register
[AllowAnonymous]
public ActionResult Register()
{
return View();
}
//
// POST: /Account/Register
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
//
// GET: /Account/ConfirmEmail
[AllowAnonymous]
public async Task<ActionResult> ConfirmEmail(string userId, string code)
{
if (userId == null || code == null)
{
return View("Error");
}
var result = await UserManager.ConfirmEmailAsync(userId, code);
return View(result.Succeeded ? "ConfirmEmail" : "Error");
}
//
// GET: /Account/ForgotPassword
[AllowAnonymous]
public ActionResult ForgotPassword()
{
return View();
}
//
// POST: /Account/ForgotPassword
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null || !(await UserManager.IsEmailConfirmedAsync(user.Id)))
{
// Don't reveal that the user does not exist or is not confirmed
return View("ForgotPasswordConfirmation");
}
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
// var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>");
// return RedirectToAction("ForgotPasswordConfirmation", "Account");
}
// If we got this far, something failed, redisplay form
return View(model);
}
//
// GET: /Account/ForgotPasswordConfirmation
[AllowAnonymous]
public ActionResult ForgotPasswordConfirmation()
{
return View();
}
//
// GET: /Account/ResetPassword
[AllowAnonymous]
public ActionResult ResetPassword(string code)
{
return code == null ? View("Error") : View();
}
//
// POST: /Account/ResetPassword
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return RedirectToAction("ResetPasswordConfirmation", "Account");
}
var result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
if (result.Succeeded)
{
return RedirectToAction("ResetPasswordConfirmation", "Account");
}
AddErrors(result);
return View();
}
//
// GET: /Account/ResetPasswordConfirmation
[AllowAnonymous]
public ActionResult ResetPasswordConfirmation()
{
return View();
}
//
// POST: /Account/ExternalLogin
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public ActionResult ExternalLogin(string provider, string returnUrl)
{
// Request a redirect to the external login provider
return new ChallengeResult(provider, Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = returnUrl }));
}
//
// GET: /Account/SendCode
[AllowAnonymous]
public async Task<ActionResult> SendCode(string returnUrl, bool rememberMe)
{
var userId = await SignInManager.GetVerifiedUserIdAsync();
if (userId == null)
{
return View("Error");
}
var userFactors = await UserManager.GetValidTwoFactorProvidersAsync(userId);
var factorOptions = userFactors.Select(purpose => new SelectListItem { Text = purpose, Value = purpose }).ToList();
return View(new SendCodeViewModel { Providers = factorOptions, ReturnUrl = returnUrl, RememberMe = rememberMe });
}
//
// POST: /Account/SendCode
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> SendCode(SendCodeViewModel model)
{
if (!ModelState.IsValid)
{
return View();
}
// Generate the token and send it
if (!await SignInManager.SendTwoFactorCodeAsync(model.SelectedProvider))
{
return View("Error");
}
return RedirectToAction("VerifyCode", new { Provider = model.SelectedProvider, ReturnUrl = model.ReturnUrl, RememberMe = model.RememberMe });
}
//
// GET: /Account/ExternalLoginCallback
[AllowAnonymous]
public async Task<ActionResult> ExternalLoginCallback(string returnUrl)
{
var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
if (loginInfo == null)
{
return RedirectToAction("Login");
}
// Sign in the user with this external login provider if the user already has a login
var result = await SignInManager.ExternalSignInAsync(loginInfo, isPersistent: false);
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = false });
case SignInStatus.Failure:
default:
// If the user does not have an account, then prompt the user to create an account
ViewBag.ReturnUrl = returnUrl;
ViewBag.LoginProvider = loginInfo.Login.LoginProvider;
return View("ExternalLoginConfirmation", new ExternalLoginConfirmationViewModel { Email = loginInfo.Email });
}
}
//
// POST: /Account/ExternalLoginConfirmation
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return RedirectToAction("Index", "Manage");
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return View("ExternalLoginFailure");
}
var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
return RedirectToLocal(returnUrl);
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return View(model);
}
//
// POST: /Account/LogOff
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult LogOff()
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
return RedirectToAction("Index", "Home");
}
//
// GET: /Account/ExternalLoginFailure
[AllowAnonymous]
public ActionResult ExternalLoginFailure()
{
return View();
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (_userManager != null)
{
_userManager.Dispose();
_userManager = null;
}
if (_signInManager != null)
{
_signInManager.Dispose();
_signInManager = null;
}
}
base.Dispose(disposing);
}
#region Helpers
// Used for XSRF protection when adding external logins
private const string XsrfKey = "XsrfId";
private IAuthenticationManager AuthenticationManager
{
get
{
return HttpContext.GetOwinContext().Authentication;
}
}
private void AddErrors(IdentityResult result)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
private ActionResult RedirectToLocal(string returnUrl)
{
if (Url.IsLocalUrl(returnUrl))
{
return Redirect(returnUrl);
}
return RedirectToAction("Index", "Home");
}
internal class ChallengeResult : HttpUnauthorizedResult
{
public ChallengeResult(string provider, string redirectUri)
: this(provider, redirectUri, null)
{
}
public ChallengeResult(string provider, string redirectUri, string userId)
{
LoginProvider = provider;
RedirectUri = redirectUri;
UserId = userId;
}
public string LoginProvider { get; set; }
public string RedirectUri { get; set; }
public string UserId { get; set; }
public override void ExecuteResult(ControllerContext context)
{
var properties = new AuthenticationProperties { RedirectUri = RedirectUri };
if (UserId != null)
{
properties.Dictionary[XsrfKey] = UserId;
}
context.HttpContext.GetOwinContext().Authentication.Challenge(properties, LoginProvider);
}
}
#endregion
}
} | 36.870103 | 174 | 0.538419 | [
"Apache-2.0"
] | chuckstar76/Subs-Demo-MSBuild | MVCTestProject/Controllers/AccountController.cs | 17,884 | C# |
namespace Sknet.InRuleGitStorage.AuthoringExtension;
public abstract class RuleApplicationServiceWrapper : IRuleApplicationServiceImplementation
{
public IRuleApplicationServiceImplementation InnerImplementation { get; }
public RuleApplicationServiceWrapper(IRuleApplicationServiceImplementation innerRuleApplicationServiceImpl)
{
InnerImplementation = innerRuleApplicationServiceImpl ?? throw new ArgumentNullException(nameof(innerRuleApplicationServiceImpl));
}
public virtual bool BindToRuleApplication(RuleRepositoryDefBase def)
{
return InnerImplementation.BindToRuleApplication(def);
}
public virtual bool CheckForPermission(RuleUserRolePermissions permission, RuleRepositoryDefBase def)
{
return InnerImplementation.CheckForPermission(permission, def);
}
public virtual bool CheckForPermission(RuleUserRolePermissions permission, RuleRepositoryDefBase def, bool showWarningMsgBox)
{
return InnerImplementation.CheckForPermission(permission, def, showWarningMsgBox);
}
public virtual bool CheckIn()
{
return InnerImplementation.CheckIn();
}
public virtual bool CheckOut(RuleRepositoryDefBase def)
{
return InnerImplementation.CheckOut(def);
}
public virtual bool CheckOut(ICollection<RuleRepositoryDefBase> defs)
{
return InnerImplementation.CheckOut(defs);
}
public virtual bool CheckOut(RuleAppCheckOutMode checkOutMode)
{
return InnerImplementation.CheckOut(checkOutMode);
}
public virtual bool CloseRequest()
{
return InnerImplementation.CloseRequest();
}
public virtual void GenerateMissingHintTables(List<RuleSetDef> ruleSets, Dictionary<Guid, List<LanguageRuleDef>> languageRules)
{
InnerImplementation.GenerateMissingHintTables(ruleSets, languageRules);
}
public virtual RuleCatalogConnection GetCatalogConnection()
{
return InnerImplementation.GetCatalogConnection();
}
public virtual bool GetLatestRevision()
{
return InnerImplementation.GetLatestRevision();
}
public virtual RuleCatalogConnection GetSpecificCatalogConnection(Uri uri)
{
return InnerImplementation.GetSpecificCatalogConnection(uri);
}
public virtual RuleCatalogConnection GetSpecificCatalogConnection(Uri uri, bool isSingleSignOn)
{
return InnerImplementation.GetSpecificCatalogConnection(uri, isSingleSignOn);
}
public virtual RuleCatalogConnection GetSpecificCatalogConnection(Uri uri, bool isSingleSignOn, string username, string password)
{
return InnerImplementation.GetSpecificCatalogConnection(uri, isSingleSignOn, username, password);
}
public virtual Guid InsertSharedElement(RuleRepositoryDefBase def)
{
return InnerImplementation.InsertSharedElement(def);
}
public virtual Guid InsertSharedRuleFlow(RuleRepositoryDefBase def)
{
return InnerImplementation.InsertSharedRuleFlow(def);
}
public virtual bool OpenFromCatalog(Uri uri, string ruleAppName)
{
return InnerImplementation.OpenFromCatalog(uri, ruleAppName);
}
public virtual bool OpenFromCatalog(Uri uri, string ruleAppName, bool isSingleSignOn)
{
return InnerImplementation.OpenFromCatalog(uri, ruleAppName, isSingleSignOn);
}
public virtual bool OpenFromCatalog(Uri uri, string ruleAppName, bool isSingleSignOn, string username, string password)
{
return InnerImplementation.OpenFromCatalog(uri, ruleAppName, isSingleSignOn, username, password);
}
public virtual bool OpenFromCatalogDialog()
{
return InnerImplementation.OpenFromCatalogDialog();
}
public virtual bool OpenFromFile()
{
return InnerImplementation.OpenFromFile();
}
public virtual bool OpenFromFilename(string filename)
{
return InnerImplementation.OpenFromFilename(filename);
}
public virtual void OpenTraceFile()
{
InnerImplementation.OpenTraceFile();
}
public virtual void OpenTraceFile(string filename)
{
InnerImplementation.OpenTraceFile(filename);
}
public virtual bool Save()
{
return InnerImplementation.Save();
}
public virtual bool SaveCopyToFile()
{
return InnerImplementation.SaveCopyToFile();
}
public virtual bool SavePendingChanges()
{
return InnerImplementation.SavePendingChanges();
}
public virtual bool SaveToCatalog(bool isSaveAs)
{
return InnerImplementation.SaveToCatalog(isSaveAs);
}
public virtual bool SaveToFile()
{
return InnerImplementation.SaveToFile();
}
public virtual void SetPermissions(RuleRepositoryDefBase def)
{
InnerImplementation.SetPermissions(def);
}
public virtual void SetSchemaPermissions()
{
InnerImplementation.SetSchemaPermissions();
}
public virtual bool SetSchemaShareable()
{
return InnerImplementation.SetSchemaShareable();
}
public virtual bool SetShareable(RuleRepositoryDefBase def)
{
return InnerImplementation.SetShareable(def);
}
public virtual bool UnbindFromRuleApplication(RuleRepositoryDefBase def)
{
return InnerImplementation.UnbindFromRuleApplication(def);
}
public virtual bool UndoCheckout(ICollection<RuleRepositoryDefBase> defs)
{
return InnerImplementation.UndoCheckout(defs);
}
public virtual bool UndoCheckout(RuleRepositoryDefBase selectedDef)
{
return InnerImplementation.UndoCheckout(selectedDef);
}
public virtual bool UndoCheckout(RuleRepositoryDefBase selectedDef, bool quiet)
{
return InnerImplementation.UndoCheckout(selectedDef, quiet);
}
public virtual bool Unshare(RuleRepositoryDefBase def)
{
return InnerImplementation.Unshare(def);
}
}
| 30.50495 | 139 | 0.708698 | [
"MIT"
] | stevenkuhn/InRuleGitStorage | src/Sknet.InRuleGitStorage.AuthoringExtension/RuleApplicationServiceWrapper.cs | 6,164 | C# |
// Copyright (c) 2020 Flucto Team and others. Licensed under the MIT Licence.
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using System;
using flucto.Platform.Windows.Native;
using osuTK;
namespace flucto.Platform.Windows
{
public class WindowsGameHost : DesktopGameHost
{
private TimePeriod timePeriod;
public override Clipboard GetClipboard() => new WindowsClipboard();
protected override Storage GetStorage(string baseName) => new WindowsStorage(baseName, this);
public override bool CapsLockEnabled => Console.CapsLock;
internal WindowsGameHost(string gameName, bool bindIPC = false, ToolkitOptions toolkitOptions = default, bool portableInstallation = false)
: base(gameName, bindIPC, toolkitOptions, portableInstallation)
{
}
protected override void SetupForRun()
{
base.SetupForRun();
// OnActivate / OnDeactivate may not fire, so the initial activity state may be unknown here.
// In order to be certain we have the correct activity state we are querying the Windows API here.
timePeriod = new TimePeriod(1) { Active = true };
Window = new WindowsGameWindow();
}
protected override void Dispose(bool isDisposing)
{
timePeriod?.Dispose();
base.Dispose(isDisposing);
}
protected override void OnActivated()
{
timePeriod.Active = true;
Execution.SetThreadExecutionState(Execution.ExecutionState.Continuous | Execution.ExecutionState.SystemRequired | Execution.ExecutionState.DisplayRequired);
base.OnActivated();
}
protected override void OnDeactivated()
{
timePeriod.Active = false;
Execution.SetThreadExecutionState(Execution.ExecutionState.Continuous);
base.OnDeactivated();
}
}
}
| 33.459016 | 168 | 0.66291 | [
"MIT"
] | flucto/flucto | flucto/Platform/Windows/WindowsGameHost.cs | 2,043 | C# |
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Threading;
using NewLife;
using XCode.Cache;
using XCode.Configuration;
using XCode.DataAccessLayer;
using XCode.Shards;
namespace XCode
{
public partial class Entity<TEntity>
{
/// <summary>实体元数据</summary>
public static class Meta
{
static Meta()
{
// 避免实际应用中，直接调用Entity.Meta的静态方法时，没有引发TEntity的静态构造函数。
var entity = new TEntity();
}
#region 主要属性
/// <summary>实体类型</summary>
public static Type ThisType => typeof(TEntity);
//private static IEntityFactory _Factory;
/// <summary>实体操作者</summary>
public static IEntityFactory Factory
{
get
{
// 不能缓存Factory，因为后期可能会改变注册，比如Menu
//if (_Factory != null) return _Factory;
var type = ThisType;
if (type.IsInterface) return null;
return /*_Factory = */type.AsFactory();
}
}
#endregion
#region 基本属性
private static readonly Lazy<TableItem> _Table = new(() => TableItem.Create(ThisType));
/// <summary>表信息</summary>
public static TableItem Table => _Table.Value;
private static readonly AsyncLocal<String> _ConnName = new();
/// <summary>链接名。线程内允许修改，修改者负责还原。若要还原默认值，设为null即可</summary>
public static String ConnName
{
get => _ConnName.Value ??= Table.ConnName;
set { _Session.Value = null; _ConnName.Value = value; }
}
private static readonly AsyncLocal<String> _TableName = new();
/// <summary>表名。线程内允许修改，修改者负责还原</summary>
public static String TableName
{
get => _TableName.Value ??= Table.TableName;
set { _Session.Value = null; _TableName.Value = value; }
}
/// <summary>所有数据属性</summary>
public static FieldItem[] AllFields => Table.AllFields;
/// <summary>所有绑定到数据表的属性</summary>
public static FieldItem[] Fields => Table.Fields;
/// <summary>字段名集合，不区分大小写的哈希表存储，外部不要修改元素数据</summary>
public static ICollection<String> FieldNames => Table.FieldNames;
/// <summary>唯一键，返回第一个标识列或者唯一的主键</summary>
public static FieldItem Unique
{
get
{
var dt = Table;
if (dt.PrimaryKeys.Length == 1) return dt.PrimaryKeys[0];
if (dt.Identity != null) return dt.Identity;
return null;
}
}
/// <summary>主字段。主字段作为业务主要字段，代表当前数据行意义</summary>
public static FieldItem Master => Table.Master ?? Unique;
#endregion
#region 会话
private static readonly AsyncLocal<EntitySession<TEntity>> _Session = new();
/// <summary>实体会话。线程静态</summary>
public static EntitySession<TEntity> Session => _Session.Value ??= EntitySession<TEntity>.Create(ConnName, TableName);
#endregion
#region 事务保护
/// <summary>开始事务</summary>
/// <returns>剩下的事务计数</returns>
//[Obsolete("=>Session")]
[EditorBrowsable(EditorBrowsableState.Never)]
public static Int32 BeginTrans() => Session.BeginTrans();
/// <summary>提交事务</summary>
/// <returns>剩下的事务计数</returns>
//[Obsolete("=>Session")]
[EditorBrowsable(EditorBrowsableState.Never)]
public static Int32 Commit() => Session.Commit();
/// <summary>回滚事务，忽略异常</summary>
/// <returns>剩下的事务计数</returns>
//[Obsolete("=>Session")]
[EditorBrowsable(EditorBrowsableState.Never)]
public static Int32 Rollback() => Session.Rollback();
/// <summary>创建事务</summary>
public static EntityTransaction CreateTrans() => new EntityTransaction<TEntity>();
#endregion
#region 辅助方法
///// <summary>格式化关键字</summary>
///// <param name="name">名称</param>
///// <returns></returns>
//public static String FormatName(String name) => Session.Dal.Db.FormatName(name);
///// <summary>格式化时间</summary>
///// <param name="dateTime"></param>
///// <returns></returns>
//public static String FormatDateTime(DateTime dateTime) => Session.Dal.Db.FormatDateTime(dateTime);
///// <summary>格式化数据为SQL数据</summary>
///// <param name="name">名称</param>
///// <param name="value">数值</param>
///// <returns></returns>
//public static String FormatValue(String name, Object value) => FormatValue(Table.FindByName(name), value);
///// <summary>格式化数据为SQL数据</summary>
///// <param name="field">字段</param>
///// <param name="value">数值</param>
///// <returns></returns>
//public static String FormatValue(FieldItem field, Object value) => Session.Dal.Db.FormatValue(field?.Field, value);
#endregion
#region 缓存
/// <summary>实体缓存</summary>
/// <returns></returns>
//[Obsolete("=>Session")]
//[EditorBrowsable(EditorBrowsableState.Never)]
public static EntityCache<TEntity> Cache => Session.Cache;
/// <summary>单对象实体缓存。</summary>
//[Obsolete("=>Session")]
//[EditorBrowsable(EditorBrowsableState.Never)]
public static ISingleEntityCache<Object, TEntity> SingleCache => Session.SingleCache;
/// <summary>总记录数，小于1000时是精确的，大于1000时缓存10分钟</summary>
//[Obsolete("=>Session")]
//[EditorBrowsable(EditorBrowsableState.Never)]
public static Int32 Count => (Int32)Session.LongCount;
#endregion
#region 分表分库
/// <summary>自动分库回调，用于添删改操作</summary>
[Obsolete("=>AutoShard")]
public static Func<TEntity, String> ShardConnName { get; set; }
/// <summary>自动分表回调，用于添删改操作</summary>
[Obsolete("=>AutoShard")]
public static Func<TEntity, String> ShardTableName { get; set; }
/// <summary>分表分库策略</summary>
public static IShardPolicy ShardPolicy { get; set; }
/// <summary>在分库上执行操作，自动还原</summary>
/// <param name="connName"></param>
/// <param name="tableName"></param>
/// <param name="func"></param>
/// <returns></returns>
[Obsolete("=>CreateSplit")]
public static T ProcessWithSplit<T>(String connName, String tableName, Func<T> func)
{
using var split = CreateSplit(connName, tableName);
return func();
}
/// <summary>创建分库会话，using结束时自动还原</summary>
/// <param name="connName">连接名</param>
/// <param name="tableName">表名</param>
/// <returns></returns>
public static IDisposable CreateSplit(String connName, String tableName) => new SplitPackge(connName, tableName);
/// <summary>针对实体对象自动分库分表</summary>
/// <param name="entity"></param>
/// <returns></returns>
public static IDisposable CreateShard(TEntity entity)
{
// 使用自动分表分库策略
var model = ShardPolicy?.Shard(entity);
if (model != null) return new SplitPackge(model.ConnName, model.TableName);
#pragma warning disable CS0618 // 类型或成员已过时
var connName = ShardConnName?.Invoke(entity);
var tableName = ShardTableName?.Invoke(entity);
if (connName.IsNullOrEmpty() && tableName.IsNullOrEmpty()) return null;
#pragma warning restore CS0618 // 类型或成员已过时
return new SplitPackge(connName, tableName);
}
/// <summary>为实体对象、时间、雪花Id等计算分表分库</summary>
/// <param name="value"></param>
/// <returns></returns>
public static IDisposable CreateShard(Object value)
{
// 使用自动分表分库策略
var model = ShardPolicy?.Shard(value);
if (model == null) return null;
return new SplitPackge(model.ConnName, model.TableName);
}
/// <summary>针对时间区间自动分库分表，常用于多表顺序查询，支持倒序</summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="callback"></param>
/// <returns></returns>
public static IEnumerable<T> AutoShard<T>(DateTime start, DateTime end, Func<T> callback)
{
// 使用自动分表分库策略
var models = ShardPolicy?.Shards(start, end);
if (models == null) yield break;
foreach (var shard in models)
{
// 如果目标分表不存在，则不要展开查询
var dal = !shard.ConnName.IsNullOrEmpty() ? DAL.Create(shard.ConnName) : Session.Dal;
if (!dal.TableNames.Contains(shard.TableName)) continue;
using var split = new SplitPackge(shard.ConnName, shard.TableName);
var rs = callback();
if (!Equals(rs, default)) yield return rs;
}
}
private class SplitPackge : IDisposable
{
/// <summary>连接名</summary>
public String ConnName { get; set; }
/// <summary>表名</summary>
public String TableName { get; set; }
public SplitPackge(String connName, String tableName)
{
ConnName = Meta.ConnName;
TableName = Meta.TableName;
Meta.ConnName = connName;
Meta.TableName = tableName;
}
public void Dispose()
{
Meta.ConnName = ConnName;
Meta.TableName = TableName;
}
}
#endregion
#region 模块
internal static EntityModules _Modules = new(typeof(TEntity));
/// <summary>实体模块集合</summary>
public static EntityModules Modules => _Modules;
#endregion
}
}
} | 39.379061 | 131 | 0.516135 | [
"MIT"
] | doujia/X | XCode/Entity/Entity_Meta.cs | 12,010 | C# |
// -----------------------------------------------------------------------
// <copyright file="DeadLetter.cs" company="Asynkron AB">
// Copyright (C) 2015-2020 Asynkron AB All rights reserved
// </copyright>
// -----------------------------------------------------------------------
// ReSharper disable once CheckNamespace
// ReSharper disable once CheckNamespace
using System;
using JetBrains.Annotations;
namespace Proto
{
[PublicAPI]
public class DeadLetterEvent
{
public DeadLetterEvent(PID pid, object message, PID? sender) : this(pid, message, sender, MessageHeader.Empty)
{
}
public DeadLetterEvent(PID pid, object message, PID? sender, MessageHeader? header)
{
Pid = pid;
Message = message;
Sender = sender;
Header = header ?? MessageHeader.Empty;
}
public PID Pid { get; }
public object Message { get; }
public PID? Sender { get; }
public MessageHeader Header { get; }
}
public class DeadLetterProcess : Process
{
public DeadLetterProcess(ActorSystem system) : base(system)
{
}
protected internal override void SendUserMessage(PID pid, object message)
{
var (msg, sender, header) = MessageEnvelope.Unwrap(message);
System.EventStream.Publish(new DeadLetterEvent(pid, msg, sender, header));
if (sender is not null && msg is not PoisonPill)
System.Root.Send(sender, new DeadLetterResponse {Target = pid});
}
protected internal override void SendSystemMessage(PID pid, object message)
=> System.EventStream.Publish(new DeadLetterEvent(pid, message, null, null));
}
public class DeadLetterException : Exception
{
public DeadLetterException(PID pid) : base($"{pid.ToShortString()} no longer exists")
{
}
}
} | 31.290323 | 118 | 0.575773 | [
"Apache-2.0"
] | sudsy/protoactor-dotnet | src/Proto.Actor/EventStream/DeadLetter.cs | 1,940 | C# |
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class FoodRespawn : MonoBehaviour
{
// Start is called before the first frame update
void Start()
{
}
// Update is called once per frame
void Update()
{
}
void OnTriggerExit(Collider collider)
{
List<int> consumed_food = transform.parent.GetComponent<Forager_Sim>().consumed_food;
if (collider.gameObject.tag == "Food" && consumed_food.Contains(collider.gameObject.GetInstanceID()))
{
consumed_food.Remove(collider.gameObject.GetInstanceID());
}
}
}
| 23.071429 | 109 | 0.647059 | [
"MIT"
] | iskaj/UnityLevySimulation | NC_Project/Scripts/FoodRespawn.cs | 648 | C# |
namespace BankSystem.Services.Models.BankAccount
{
public class BankAccountVerifyOwnershipServiceModel : BankAccountBaseServiceModel
{
public string UserId { get; set; }
}
} | 27.714286 | 85 | 0.742268 | [
"MIT"
] | AmilkarDev/BankSystem | src/Services/BankSystem/BankSystem.Services.Models/BankAccount/BankAccountVerifyOwnershipServiceModel.cs | 196 | C# |
#if !NO_RUNTIME
using System;
using ProtoBuf.Meta;
#if FEAT_IKVM
using Type = IKVM.Reflection.Type;
using IKVM.Reflection;
#else
using System.Reflection;
#endif
namespace ProtoBuf.Serializers
{
sealed class TagDecorator : ProtoDecoratorBase, IProtoTypeSerializer
{
public bool HasCallbacks(TypeModel.CallbackType callbackType)
{
IProtoTypeSerializer pts = Tail as IProtoTypeSerializer;
return pts != null && pts.HasCallbacks(callbackType);
}
public bool CanCreateInstance()
{
IProtoTypeSerializer pts = Tail as IProtoTypeSerializer;
return pts != null && pts.CanCreateInstance();
}
#if !FEAT_IKVM
public object CreateInstance(ProtoReader source)
{
return ((IProtoTypeSerializer)Tail).CreateInstance(source);
}
public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context)
{
IProtoTypeSerializer pts = Tail as IProtoTypeSerializer;
if (pts != null) pts.Callback(value, callbackType, context);
}
#endif
#if UNITY_STANDALONE || UNITY_ANDROID || UNITY_IOS || UNITY_WSA || SERVICE
public void EmitCallback(Compiler.CompilerContext ctx, Compiler.Local valueFrom, TypeModel.CallbackType callbackType)
{
// we only expect this to be invoked if HasCallbacks returned true, so implicitly Tail
// **must** be of the correct type
((IProtoTypeSerializer)Tail).EmitCallback(ctx, valueFrom, callbackType);
}
public void EmitCreateInstance(Compiler.CompilerContext ctx)
{
((IProtoTypeSerializer)Tail).EmitCreateInstance(ctx);
}
#endif
public override Type ExpectedType
{
get { return Tail.ExpectedType; }
}
public TagDecorator(int fieldNumber, WireType wireType, bool strict, IProtoSerializer tail)
: base(tail)
{
this.fieldNumber = fieldNumber;
this.wireType = wireType;
this.strict = strict;
}
public override bool RequiresOldValue { get { return Tail.RequiresOldValue; } }
public override bool ReturnsValue { get { return Tail.ReturnsValue; } }
private readonly bool strict;
private readonly int fieldNumber;
private readonly WireType wireType;
private bool NeedsHint
{
get { return ((int)wireType & ~7) != 0; }
}
#if !FEAT_IKVM
public override object Read(object value, ProtoReader source)
{
Helpers.DebugAssert(fieldNumber == source.FieldNumber);
if (strict) { source.Assert(wireType); }
else if (NeedsHint) { source.Hint(wireType); }
return Tail.Read(value, source);
}
public override void Write(object value, ProtoWriter dest)
{
ProtoWriter.WriteFieldHeader(fieldNumber, wireType, dest);
Tail.Write(value, dest);
}
#endif
#if UNITY_STANDALONE || UNITY_ANDROID || UNITY_IOS || UNITY_WSA || SERVICE
protected override void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
ctx.LoadValue(fieldNumber);
ctx.LoadValue((int)wireType);
ctx.LoadReaderWriter();
ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod("WriteFieldHeader"));
Tail.EmitWrite(ctx, valueFrom);
}
protected override void EmitRead(ProtoBuf.Compiler.CompilerContext ctx, ProtoBuf.Compiler.Local valueFrom)
{
if (strict || NeedsHint)
{
ctx.LoadReaderWriter();
ctx.LoadValue((int)wireType);
ctx.EmitCall(ctx.MapType(typeof(ProtoReader)).GetMethod(strict ? "Assert" : "Hint"));
}
Tail.EmitRead(ctx, valueFrom);
}
#endif
}
}
#endif | 35.25 | 125 | 0.6269 | [
"MIT"
] | a1475775412/GameDesigner | GameDesigner/Serialize/protobuf-net/Serializers/TagDecorator.cs | 3,950 | C# |
public class Wizard:AbstractHero
{
private const int WizardStrength = 25;
private const int WizardAgility = 25;
private const int WizardIntelligence = 100;
private const int WizardHitPoints = 100;
private const int WizardDamage = 250;
public Wizard(string name)
: base(name, WizardStrength, WizardAgility, WizardIntelligence, WizardHitPoints, WizardDamage)
{
}
} | 29 | 102 | 0.716749 | [
"MIT"
] | mkpetrov/OOP-Advanced | Exam-Prep/Hell-Skeleton/Hell-Skeleton/Hell/Entities/Heroes/Wizard.cs | 408 | C# |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("02.CoffeMachine")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("02.CoffeMachine")]
[assembly: AssemblyCopyright("Copyright © 2017")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("06697fa8-da98-4f10-b782-659b83a99eb6")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
| 37.918919 | 84 | 0.744833 | [
"MIT"
] | George221b/SoftUni-Taks | C#OOP-Advanced/04.EnumsAndAttributes-Lab/02.CoffeMachine/Properties/AssemblyInfo.cs | 1,406 | C# |
using System;
// ASM: a very small and fast Java bytecode manipulation framework
// Copyright (c) 2000-2011 INRIA, France Telecom
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holders nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
namespace ObjectWeb.Asm
{
/// <summary>
/// A position in the bytecode of a method. Labels are used for jump, goto, and switch instructions,
/// and for try catch blocks. A label designates the <i>instruction</i> that is just after. Note
/// however that there can be other elements between a label and the instruction it designates (such
/// as other labels, stack map frames, line numbers, etc.).
/// @author Eric Bruneton
/// </summary>
public class Label
{
/// <summary>
/// A flag indicating that a label is only used for debug attributes. Such a label is not the start
/// of a basic block, the target of a jump instruction, or an exception handler. It can be safely
/// ignored in control flow graph analysis algorithms (for optimization purposes).
/// </summary>
internal const int Flag_Debug_Only = 1;
/// <summary>
/// A flag indicating that a label is the target of a jump instruction, or the start of an
/// exception handler.
/// </summary>
internal const int Flag_Jump_Target = 2;
/// <summary>
/// A flag indicating that the bytecode offset of a label is known.
/// </summary>
internal const int Flag_Resolved = 4;
/// <summary>
/// A flag indicating that a label corresponds to a reachable basic block.
/// </summary>
internal const int Flag_Reachable = 8;
/// <summary>
/// A flag indicating that the basic block corresponding to a label ends with a subroutine call. By
/// construction in <seealso cref = "MethodWriter.VisitJumpInsn"/>, labels with this flag set have at least two
/// outgoing edges:
/// <ul>
/// <li>
/// the first one corresponds to the instruction that follows the jsr instruction in the
/// bytecode, i.e. where execution continues when it returns from the jsr call. This is a
/// virtual control flow edge, since execution never goes directly from the jsr to the next
/// instruction. Instead, it goes to the subroutine and eventually returns to the instruction
/// following the jsr. This virtual edge is used to compute the real outgoing edges of the
/// basic blocks ending with a ret instruction, in <seealso cref = "AddSubroutineRetSuccessors"/>.
/// <li>the second one corresponds to the target of the jsr instruction,
/// </ul>
/// </summary>
internal const int Flag_Subroutine_Caller = 16;
/// <summary>
/// A flag indicating that the basic block corresponding to a label is the start of a subroutine.
/// </summary>
internal const int Flag_Subroutine_Start = 32;
/// <summary>
/// A flag indicating that the basic block corresponding to a label is the end of a subroutine.
/// </summary>
internal const int Flag_Subroutine_End = 64;
/// <summary>
/// The number of elements to add to the <seealso cref = "_otherLineNumbers"/> array when it needs to be
/// resized to store a new source line number.
/// </summary>
internal const int Line_Numbers_Capacity_Increment = 4;
/// <summary>
/// The number of elements to add to the <seealso cref = "_forwardReferences"/> array when it needs to be
/// resized to store a new forward reference.
/// </summary>
internal const int Forward_References_Capacity_Increment = 6;
/// <summary>
/// The bit mask to extract the type of a forward reference to this label. The extracted type is
/// either <seealso cref = "Forward_Reference_Type_Short"/> or <seealso cref = "Forward_Reference_Type_Wide"/>.
/// </summary>
/// <seealso cref = # forwardReferences
/// </seealso>
internal const int Forward_Reference_Type_Mask = unchecked((int)0xF0000000);
/// <summary>
/// The type of forward references stored with two bytes in the bytecode. This is the case, for
/// instance, of a forward reference from an ifnull instruction.
/// </summary>
internal const int Forward_Reference_Type_Short = 0x10000000;
/// <summary>
/// The type of forward references stored in four bytes in the bytecode. This is the case, for
/// instance, of a forward reference from a lookupswitch instruction.
/// </summary>
internal const int Forward_Reference_Type_Wide = 0x20000000;
/// <summary>
/// The bit mask to extract the 'handle' of a forward reference to this label. The extracted handle
/// is the bytecode offset where the forward reference value is stored (using either 2 or 4 bytes,
/// as indicated by the <seealso cref = "Forward_Reference_Type_Mask"/>).
/// </summary>
/// <seealso cref = # forwardReferences
/// </seealso>
internal const int Forward_Reference_Handle_Mask = 0x0FFFFFFF;
/// <summary>
/// A sentinel element used to indicate the end of a list of labels.
/// </summary>
/// <seealso cref = # nextListElement
/// </seealso>
internal static readonly Label EmptyList = new();
/// <summary>
/// The offset of this label in the bytecode of its method, in bytes. This value is set if and only
/// if the <seealso cref = "Flag_Resolved"/> flag is set.
/// </summary>
internal int bytecodeOffset;
/// <summary>
/// The type and status of this label or its corresponding basic block. Must be zero or more of
/// <seealso cref = "Flag_Debug_Only"/>, <seealso cref = "Flag_Jump_Target"/>, <seealso cref = "Flag_Resolved"/>, {@link
/// #FLAG_REACHABLE}, <seealso cref = "Flag_Subroutine_Caller"/>, <seealso cref = "Flag_Subroutine_Start"/>, {@link
/// #FLAG_SUBROUTINE_END}.
/// </summary>
internal short flags;
/// <summary>
/// The forward references to this label. The first element is the number of forward references,
/// times 2 (this corresponds to the index of the last element actually used in this array). Then,
/// each forward reference is described with two consecutive integers noted
/// 'sourceInsnBytecodeOffset' and 'reference':
/// <ul>
/// <li>
/// 'sourceInsnBytecodeOffset' is the bytecode offset of the instruction that contains the
/// forward reference,
/// <li>
/// 'reference' contains the type and the offset in the bytecode where the forward reference
/// value must be stored, which can be extracted with <seealso cref = "Forward_Reference_Type_Mask"/>
/// and <seealso cref = "Forward_Reference_Handle_Mask"/>.
/// </ul>
/// <para>
/// For instance, for an ifnull instruction at bytecode offset x, 'sourceInsnBytecodeOffset' is
/// equal to x, and 'reference' is of type <seealso cref = "Forward_Reference_Type_Short"/> with value x + 1
/// (because the ifnull instruction uses a 2 bytes bytecode offset operand stored one byte after
/// the start of the instruction itself). For the default case of a lookupswitch instruction at
/// bytecode offset x, 'sourceInsnBytecodeOffset' is equal to x, and 'reference' is of type {@link
/// #FORWARD_REFERENCE_TYPE_WIDE} with value between x + 1 and x + 4 (because the lookupswitch
/// instruction uses a 4 bytes bytecode offset operand stored one to four bytes after the start of
/// the instruction itself).
/// </para>
/// </summary>
private int[] _forwardReferences;
/// <summary>
/// The input and output stack map frames of the basic block corresponding to this label. This
/// field is only used when the <seealso cref = "MethodWriter.Compute_All_Frames"/> or {@link
/// MethodWriter#COMPUTE_INSERTED_FRAMES} option is used.
/// </summary>
internal Frame frame;
/// <summary>
/// A user managed state associated with this label. Warning: this field is used by the ASM tree
/// package. In order to use it with the ASM tree package you must override the getLabelNode method
/// in MethodNode.
/// </summary>
public object Info { get; set; }
// -----------------------------------------------------------------------------------------------
// Fields for the control flow and data flow graph analysis algorithms (used to compute the
// maximum stack size or the stack map frames). A control flow graph contains one node per "basic
// block", and one edge per "jump" from one basic block to another. Each node (i.e., each basic
// block) is represented with the Label object that corresponds to the first instruction of this
// basic block. Each node also stores the list of its successors in the graph, as a linked list of
// Edge objects.
//
// The control flow analysis algorithms used to compute the maximum stack size or the stack map
// frames are similar and use two steps. The first step, during the visit of each instruction,
// builds information about the state of the local variables and the operand stack at the end of
// each basic block, called the "output frame", <i>relatively</i> to the frame state at the
// beginning of the basic block, which is called the "input frame", and which is <i>unknown</i>
// during this step. The second step, in {@link MethodWriter#computeAllFrames} and {@link
// MethodWriter#computeMaxStackAndLocal}, is a fix point algorithm
// that computes information about the input frame of each basic block, from the input state of
// the first basic block (known from the method signature), and by the using the previously
// computed relative output frames.
//
// The algorithm used to compute the maximum stack size only computes the relative output and
// absolute input stack heights, while the algorithm used to compute stack map frames computes
// relative output frames and absolute input frames.
/// <summary>
/// The number of elements in the input stack of the basic block corresponding to this label. This
/// field is computed in <seealso cref = "MethodWriter.ComputeMaxStackAndLocal"/>.
/// </summary>
internal short inputStackSize;
/// <summary>
/// The source line number corresponding to this label, or 0. If there are several source line
/// numbers corresponding to this label, the first one is stored in this field, and the remaining
/// ones are stored in <seealso cref = "_otherLineNumbers"/>.
/// </summary>
private short _lineNumber;
/// <summary>
/// The successor of this label, in the order they are visited in <seealso cref = "MethodVisitor.VisitLabel"/>.
/// This linked list does not include labels used for debug info only. If the {@link
/// MethodWriter#COMPUTE_ALL_FRAMES} or <seealso cref = "MethodWriter.Compute_Inserted_Frames"/> option is used
/// then it does not contain either successive labels that denote the same bytecode offset (in this
/// case only the first label appears in this list).
/// </summary>
internal Label nextBasicBlock;
/// <summary>
/// The next element in the list of labels to which this label belongs, or {@literal null} if it
/// does not belong to any list. All lists of labels must end with the <seealso cref = "EmptyList"/>
/// sentinel, in order to ensure that this field is null if and only if this label does not belong
/// to a list of labels. Note that there can be several lists of labels at the same time, but that
/// a label can belong to at most one list at a time (unless some lists share a common tail, but
/// this is not used in practice).
/// <para>
/// List of labels are used in <seealso cref = "MethodWriter.ComputeAllFrames"/> and {@link
/// MethodWriter#computeMaxStackAndLocal} to compute stack map frames and the maximum stack size,
/// respectively, as well as in <seealso cref = "MarkSubroutine"/> and <seealso cref = "AddSubroutineRetSuccessors"/>
/// to
/// compute the basic blocks belonging to subroutines and their outgoing edges. Outside of these
/// methods, this field should be null (this property is a precondition and a postcondition of
/// these methods).
/// </para>
/// </summary>
internal Label nextListElement;
/// <summary>
/// The source line numbers corresponding to this label, in addition to <seealso cref = "_lineNumber"/>, or
/// null. The first element of this array is the number n of source line numbers it contains, which
/// are stored between indices 1 and n (inclusive).
/// </summary>
private int[] _otherLineNumbers;
/// <summary>
/// The outgoing edges of the basic block corresponding to this label, in the control flow graph of
/// its method. These edges are stored in a linked list of <seealso cref = "Edge"/> objects, linked to each
/// other by their <seealso cref = "Edge.nextEdge"/> field.
/// </summary>
internal Edge outgoingEdges;
/// <summary>
/// The maximum height reached by the output stack, relatively to the top of the input stack, in
/// the basic block corresponding to this label. This maximum is always positive or {@literal
/// null}.
/// </summary>
internal short outputStackMax;
/// <summary>
/// The number of elements in the output stack, at the end of the basic block corresponding to this
/// label. This field is only computed for basic blocks that end with a RET instruction.
/// </summary>
internal short outputStackSize;
/// <summary>
/// The id of the subroutine to which this basic block belongs, or 0. If the basic block belongs to
/// several subroutines, this is the id of the "oldest" subroutine that contains it (with the
/// convention that a subroutine calling another one is "older" than the callee). This field is
/// computed in <seealso cref = "MethodWriter.ComputeMaxStackAndLocal"/>, if the method contains JSR
/// instructions.
/// </summary>
internal short subroutineId;
// -----------------------------------------------------------------------------------------------
// Constructor and accessors
// -----------------------------------------------------------------------------------------------
/// <summary>
/// Returns the bytecode offset corresponding to this label. This offset is computed from the start
/// of the method's bytecode.
/// <i>
/// This method is intended for <seealso cref = "Attribute"/> sub classes, and is
/// normally not needed by class generators or adapters.
/// </i>
/// </summary>
/// <returns> the bytecode offset corresponding to this label. </returns>
/// <exception cref = "IllegalStateException"> if this label is not resolved yet. </exception>
public virtual int Offset
{
get
{
if ((flags & Flag_Resolved) == 0)
throw new InvalidOperationException("Label offset position has not been resolved yet");
return bytecodeOffset;
}
}
/// <summary>
/// Returns the "canonical" <seealso cref = "Label"/> instance corresponding to this label's bytecode offset,
/// if known, otherwise the label itself. The canonical instance is the first label (in the order
/// of their visit by <seealso cref = "MethodVisitor.VisitLabel"/>) corresponding to this bytecode offset. It
/// cannot be known for labels which have not been visited yet.
/// <para>
/// <i>
/// This method should only be used when the <seealso cref = "MethodWriter.Compute_All_Frames"/> option
/// is used.
/// </i>
/// </para>
/// </summary>
/// <returns>
/// the label itself if <seealso cref = "frame"/> is null, otherwise the Label's frame owner. This
/// corresponds to the "canonical" label instance described above thanks to the way the label
/// frame is set in <seealso cref = "MethodWriter.VisitLabel"/>.
/// </returns>
public Label CanonicalInstance => frame == null ? this : frame.owner;
// -----------------------------------------------------------------------------------------------
// Methods to manage line numbers
// -----------------------------------------------------------------------------------------------
/// <summary>
/// Adds a source line number corresponding to this label.
/// </summary>
/// <param name = "lineNumber"> a source line number (which should be strictly positive). </param>
public void AddLineNumber(int lineNumber)
{
if (this._lineNumber == 0)
{
this._lineNumber = (short)lineNumber;
}
else
{
if (_otherLineNumbers == null)
_otherLineNumbers = new int[Line_Numbers_Capacity_Increment];
var otherLineNumberIndex = ++_otherLineNumbers[0];
if (otherLineNumberIndex >= _otherLineNumbers.Length)
{
var newLineNumbers = new int[_otherLineNumbers.Length + Line_Numbers_Capacity_Increment];
Array.Copy(_otherLineNumbers, 0, newLineNumbers, 0, _otherLineNumbers.Length);
_otherLineNumbers = newLineNumbers;
}
_otherLineNumbers[otherLineNumberIndex] = lineNumber;
}
}
/// <summary>
/// Makes the given visitor visit this label and its source line numbers, if applicable.
/// </summary>
/// <param name = "methodVisitor"> a method visitor. </param>
/// <param name = "visitLineNumbers"> whether to visit of the label's source line numbers, if any. </param>
public void Accept(MethodVisitor methodVisitor, bool visitLineNumbers)
{
methodVisitor.VisitLabel(this);
if (visitLineNumbers && _lineNumber != 0)
{
methodVisitor.VisitLineNumber(_lineNumber & 0xFFFF, this);
if (_otherLineNumbers != null)
for (var i = 1; i <= _otherLineNumbers[0]; ++i)
methodVisitor.VisitLineNumber(_otherLineNumbers[i], this);
}
}
// -----------------------------------------------------------------------------------------------
// Methods to compute offsets and to manage forward references
// -----------------------------------------------------------------------------------------------
/// <summary>
/// Puts a reference to this label in the bytecode of a method. If the bytecode offset of the label
/// is known, the relative bytecode offset between the label and the instruction referencing it is
/// computed and written directly. Otherwise, a null relative offset is written and a new forward
/// reference is declared for this label.
/// </summary>
/// <param name = "code"> the bytecode of the method. This is where the reference is appended. </param>
/// <param name = "sourceInsnBytecodeOffset">
/// the bytecode offset of the instruction that contains the
/// reference to be appended.
/// </param>
/// <param name = "wideReference"> whether the reference must be stored in 4 bytes (instead of 2 bytes). </param>
public void Put(ByteVector code, int sourceInsnBytecodeOffset, bool wideReference)
{
if ((flags & Flag_Resolved) == 0)
{
if (wideReference)
{
AddForwardReference(sourceInsnBytecodeOffset, Forward_Reference_Type_Wide, code.length);
code.PutInt(-1);
}
else
{
AddForwardReference(sourceInsnBytecodeOffset, Forward_Reference_Type_Short, code.length);
code.PutShort(-1);
}
}
else
{
if (wideReference)
code.PutInt(bytecodeOffset - sourceInsnBytecodeOffset);
else
code.PutShort(bytecodeOffset - sourceInsnBytecodeOffset);
}
}
/// <summary>
/// Adds a forward reference to this label. This method must be called only for a true forward
/// reference, i.e. only if this label is not resolved yet. For backward references, the relative
/// bytecode offset of the reference can be, and must be, computed and stored directly.
/// </summary>
/// <param name = "sourceInsnBytecodeOffset">
/// the bytecode offset of the instruction that contains the
/// reference stored at referenceHandle.
/// </param>
/// <param name = "referenceType">
/// either <seealso cref = "Forward_Reference_Type_Short"/> or {@link
/// #FORWARD_REFERENCE_TYPE_WIDE}.
/// </param>
/// <param name = "referenceHandle">
/// the offset in the bytecode where the forward reference value must be
/// stored.
/// </param>
private void AddForwardReference(int sourceInsnBytecodeOffset, int referenceType, int referenceHandle)
{
if (_forwardReferences == null)
_forwardReferences = new int[Forward_References_Capacity_Increment];
var lastElementIndex = _forwardReferences[0];
if (lastElementIndex + 2 >= _forwardReferences.Length)
{
var newValues = new int[_forwardReferences.Length + Forward_References_Capacity_Increment];
Array.Copy(_forwardReferences, 0, newValues, 0, _forwardReferences.Length);
_forwardReferences = newValues;
}
_forwardReferences[++lastElementIndex] = sourceInsnBytecodeOffset;
_forwardReferences[++lastElementIndex] = referenceType | referenceHandle;
_forwardReferences[0] = lastElementIndex;
}
/// <summary>
/// Sets the bytecode offset of this label to the given value and resolves the forward references
/// to this label, if any. This method must be called when this label is added to the bytecode of
/// the method, i.e. when its bytecode offset becomes known. This method fills in the blanks that
/// where left in the bytecode by each forward reference previously added to this label.
/// </summary>
/// <param name = "code"> the bytecode of the method. </param>
/// <param name = "bytecodeOffset"> the bytecode offset of this label. </param>
/// <returns>
/// {@literal true} if a blank that was left for this label was too small to store the
/// offset. In such a case the corresponding jump instruction is replaced with an equivalent
/// ASM specific instruction using an unsigned two bytes offset. These ASM specific
/// instructions are later replaced with standard bytecode instructions with wider offsets (4
/// bytes instead of 2), in ClassReader.
/// </returns>
public bool Resolve(byte[] code, int bytecodeOffset)
{
flags |= Flag_Resolved;
this.bytecodeOffset = bytecodeOffset;
if (_forwardReferences == null)
return false;
var hasAsmInstructions = false;
for (var i = _forwardReferences[0]; i > 0; i -= 2)
{
var sourceInsnBytecodeOffset = _forwardReferences[i - 1];
var reference = _forwardReferences[i];
var relativeOffset = bytecodeOffset - sourceInsnBytecodeOffset;
var handle = reference & Forward_Reference_Handle_Mask;
if ((reference & Forward_Reference_Type_Mask) == Forward_Reference_Type_Short)
{
if (relativeOffset < short.MinValue || relativeOffset > short.MaxValue)
{
// Change the opcode of the jump instruction, in order to be able to find it later in
// ClassReader. These ASM specific opcodes are similar to jump instruction opcodes, except
// that the 2 bytes offset is unsigned (and can therefore represent values from 0 to
// 65535, which is sufficient since the size of a method is limited to 65535 bytes).
var opcode = code[sourceInsnBytecodeOffset] & 0xFF;
if (opcode < IOpcodes.Ifnull)
// Change IFEQ ... JSR to ASM_IFEQ ... ASM_JSR.
code[sourceInsnBytecodeOffset] = (byte)(opcode + Constants.Asm_Opcode_Delta);
else
// Change IFNULL and IFNONNULL to ASM_IFNULL and ASM_IFNONNULL.
code[sourceInsnBytecodeOffset] = (byte)(opcode + Constants.Asm_Ifnull_Opcode_Delta);
hasAsmInstructions = true;
}
code[handle++] = (byte)(int)((uint)relativeOffset >> 8);
code[handle] = (byte)relativeOffset;
}
else
{
code[handle++] = (byte)(int)((uint)relativeOffset >> 24);
code[handle++] = (byte)(int)((uint)relativeOffset >> 16);
code[handle++] = (byte)(int)((uint)relativeOffset >> 8);
code[handle] = (byte)relativeOffset;
}
}
return hasAsmInstructions;
}
// -----------------------------------------------------------------------------------------------
// Methods related to subroutines
// -----------------------------------------------------------------------------------------------
/// <summary>
/// Finds the basic blocks that belong to the subroutine starting with the basic block
/// corresponding to this label, and marks these blocks as belonging to this subroutine. This
/// method follows the control flow graph to find all the blocks that are reachable from the
/// current basic block WITHOUT following any jsr target.
/// <para>
/// Note: a precondition and postcondition of this method is that all labels must have a null
/// <seealso cref = "nextListElement"/>.
/// </para>
/// </summary>
/// <param name = "subroutineId">
/// the id of the subroutine starting with the basic block corresponding to
/// this label.
/// </param>
public void MarkSubroutine(short subroutineId)
{
// Data flow algorithm: put this basic block in a list of blocks to process (which are blocks
// belonging to subroutine subroutineId) and, while there are blocks to process, remove one from
// the list, mark it as belonging to the subroutine, and add its successor basic blocks in the
// control flow graph to the list of blocks to process (if not already done).
var listOfBlocksToProcess = this;
listOfBlocksToProcess.nextListElement = EmptyList;
while (listOfBlocksToProcess != EmptyList)
{
// Remove a basic block from the list of blocks to process.
var basicBlock = listOfBlocksToProcess;
listOfBlocksToProcess = listOfBlocksToProcess.nextListElement;
basicBlock.nextListElement = null;
// If it is not already marked as belonging to a subroutine, mark it as belonging to
// subroutineId and add its successors to the list of blocks to process (unless already done).
if (basicBlock.subroutineId == 0)
{
basicBlock.subroutineId = subroutineId;
listOfBlocksToProcess = basicBlock.PushSuccessors(listOfBlocksToProcess);
}
}
}
/// <summary>
/// Finds the basic blocks that end a subroutine starting with the basic block corresponding to
/// this label and, for each one of them, adds an outgoing edge to the basic block following the
/// given subroutine call. In other words, completes the control flow graph by adding the edges
/// corresponding to the return from this subroutine, when called from the given caller basic
/// block.
/// <para>
/// Note: a precondition and postcondition of this method is that all labels must have a null
/// <seealso cref = "nextListElement"/>.
/// </para>
/// </summary>
/// <param name = "subroutineCaller">
/// a basic block that ends with a jsr to the basic block corresponding to
/// this label. This label is supposed to correspond to the start of a subroutine.
/// </param>
public void AddSubroutineRetSuccessors(Label subroutineCaller)
{
// Data flow algorithm: put this basic block in a list blocks to process (which are blocks
// belonging to a subroutine starting with this label) and, while there are blocks to process,
// remove one from the list, put it in a list of blocks that have been processed, add a return
// edge to the successor of subroutineCaller if applicable, and add its successor basic blocks
// in the control flow graph to the list of blocks to process (if not already done).
var listOfProcessedBlocks = EmptyList;
var listOfBlocksToProcess = this;
listOfBlocksToProcess.nextListElement = EmptyList;
while (listOfBlocksToProcess != EmptyList)
{
// Move a basic block from the list of blocks to process to the list of processed blocks.
var basicBlock = listOfBlocksToProcess;
listOfBlocksToProcess = basicBlock.nextListElement;
basicBlock.nextListElement = listOfProcessedBlocks;
listOfProcessedBlocks = basicBlock;
// Add an edge from this block to the successor of the caller basic block, if this block is
// the end of a subroutine and if this block and subroutineCaller do not belong to the same
// subroutine.
if ((basicBlock.flags & Flag_Subroutine_End) != 0 && basicBlock.subroutineId != subroutineCaller.subroutineId)
basicBlock.outgoingEdges = new Edge(basicBlock.outputStackSize, subroutineCaller.outgoingEdges.successor, basicBlock.outgoingEdges);
// Add its successors to the list of blocks to process. Note that {@link #pushSuccessors} does
// not push basic blocks which are already in a list. Here this means either in the list of
// blocks to process, or in the list of already processed blocks. This second list is
// important to make sure we don't reprocess an already processed block.
listOfBlocksToProcess = basicBlock.PushSuccessors(listOfBlocksToProcess);
}
// Reset the {@link #nextListElement} of all the basic blocks that have been processed to null,
// so that this method can be called again with a different subroutine or subroutine caller.
while (listOfProcessedBlocks != EmptyList)
{
var newListOfProcessedBlocks = listOfProcessedBlocks.nextListElement;
listOfProcessedBlocks.nextListElement = null;
listOfProcessedBlocks = newListOfProcessedBlocks;
}
}
/// <summary>
/// Adds the successors of this label in the method's control flow graph (except those
/// corresponding to a jsr target, and those already in a list of labels) to the given list of
/// blocks to process, and returns the new list.
/// </summary>
/// <param name = "listOfLabelsToProcess">
/// a list of basic blocks to process, linked together with their
/// <seealso cref = "nextListElement"/> field.
/// </param>
/// <returns> the new list of blocks to process. </returns>
private Label PushSuccessors(Label listOfLabelsToProcess)
{
var newListOfLabelsToProcess = listOfLabelsToProcess;
var outgoingEdge = outgoingEdges;
while (outgoingEdge != null)
{
// By construction, the second outgoing edge of a basic block that ends with a jsr instruction
// leads to the jsr target (see {@link #FLAG_SUBROUTINE_CALLER}).
var isJsrTarget = (flags & Flag_Subroutine_Caller) != 0 && outgoingEdge == outgoingEdges.nextEdge;
if (!isJsrTarget && outgoingEdge.successor.nextListElement == null)
{
// Add this successor to the list of blocks to process, if it does not already belong to a
// list of labels.
outgoingEdge.successor.nextListElement = newListOfLabelsToProcess;
newListOfLabelsToProcess = outgoingEdge.successor;
}
outgoingEdge = outgoingEdge.nextEdge;
}
return newListOfLabelsToProcess;
}
// -----------------------------------------------------------------------------------------------
// Overridden Object methods
// -----------------------------------------------------------------------------------------------
/// <summary>
/// Returns a string representation of this label.
/// </summary>
/// <returns> a string representation of this label. </returns>
public override string ToString()
{
return "L" + this.GetHashCode();
}
}
} | 59.518341 | 152 | 0.589796 | [
"BSD-3-Clause"
] | CursedJvmSharp/ObjectWeb.Asm | ObjectWeb.Asm/ObjectWeb/Asm/Label.cs | 37,318 | C# |
/*
* QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
* Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
using System;
using System.Linq;
namespace QuantConnect.Indicators
{
/// <summary>
/// Oscillator indicator that measures momentum and mean-reversion over a specified
/// period n.
/// Source: Harris, Michael. "Momersion Indicator." Price Action Lab.,
/// 13 Aug. 2015. Web. http://www.priceactionlab.com/Blog/2015/08/momersion-indicator/.
/// </summary>
public class MomersionIndicator : WindowIndicator<IndicatorDataPoint>, IIndicatorWarmUpPeriodProvider
{
/// <summary>
/// The minimum observations needed to consider the indicator ready. After that observation
/// number is reached, the indicator will continue gathering data until the full period.
/// </summary>
private readonly int? _minPeriod;
/// <summary>
/// The rolling window used to store the momentum.
/// </summary>
private readonly RollingWindow<decimal> _multipliedDiffWindow;
/// <summary>
/// Initializes a new instance of the <see cref="MomersionIndicator"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="minPeriod">The minimum period.</param>
/// <param name="fullPeriod">The full period.</param>
/// <exception cref="System.ArgumentException">The minimum period should be greater of 3.;minPeriod</exception>
public MomersionIndicator(string name, int? minPeriod, int fullPeriod)
: base(name, fullPeriod)
{
if (minPeriod < 4)
{
throw new ArgumentException("The minimum period should be 4.", "minPeriod");
}
_minPeriod = minPeriod;
_multipliedDiffWindow = new RollingWindow<decimal>(fullPeriod);
WarmUpPeriod = (minPeriod + 2) ?? (fullPeriod + 3);
}
/// <summary>
/// Initializes a new instance of the <see cref="MomersionIndicator"/> class.
/// </summary>
/// <param name="minPeriod">The minimum period.</param>
/// <param name="fullPeriod">The full period.</param>
public MomersionIndicator(int? minPeriod, int fullPeriod)
: this($"Momersion({minPeriod},{fullPeriod})", minPeriod, fullPeriod)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MomersionIndicator"/> class.
/// </summary>
/// <param name="fullPeriod">The full period.</param>
public MomersionIndicator(int fullPeriod)
: this(null, fullPeriod)
{
}
/// <summary>
/// Gets a flag indicating when this indicator is ready and fully initialized
/// </summary>
public override bool IsReady
{
get
{
if (_minPeriod.HasValue)
{
return _multipliedDiffWindow.Count >= _minPeriod;
}
return _multipliedDiffWindow.Samples > _multipliedDiffWindow.Size;
}
}
/// <summary>
/// Required period, in data points, for the indicator to be ready and fully initialized.
/// </summary>
public int WarmUpPeriod { get; }
/// <summary>
/// Resets this indicator to its initial state
/// </summary>
public override void Reset()
{
base.Reset();
_multipliedDiffWindow.Reset();
}
/// <summary>
/// Computes the next value of this indicator from the given state
/// </summary>
/// <param name="window"></param>
/// <param name="input">The input given to the indicator</param>
/// <returns>
/// A new value for this indicator
/// </returns>
protected override decimal ComputeNextValue(IReadOnlyWindow<IndicatorDataPoint> window, IndicatorDataPoint input)
{
if (window.Count >= 3)
{
_multipliedDiffWindow.Add((window[0] - window[1]) * (window[1] - window[2]));
}
// Estimate the indicator if less than 50% of observation are zero. Avoid division by
// zero and estimations with few real observations in case of forward filled data.
if (IsReady && _multipliedDiffWindow.Count(obs => obs == 0) < 0.5 * _multipliedDiffWindow.Count)
{
var mc = _multipliedDiffWindow.Count(obs => obs > 0);
var mRc = _multipliedDiffWindow.Count(obs => obs < 0);
return 100m * mc / (mc + mRc);
}
return 50m;
}
}
} | 39.858209 | 121 | 0.599139 | [
"Apache-2.0"
] | 9812334/Lean | Indicators/Momersion.cs | 5,343 | C# |
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace OpenKh.Tools.BarEditor.Properties
{
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources
{
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources()
{
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager
{
get
{
if ((resourceMan == null))
{
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("OpenKh.Tools.BarEditor.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
}
}
| 34.069444 | 173 | 0.690583 | [
"Apache-2.0"
] | 1234567890num/OpenKh | OpenKh.Tools.BarEditor/Properties/Resources.Designer.cs | 2,455 | C# |
using Musaca.Data.Models;
using Musaca.Models.Users;
using Musaca.Services;
using MvcFramework;
using MvcFramework.Attributes.Http;
using MvcFramework.Attributes.Security;
using MvcFramework.AutoMapper.Extensions;
using MvcFramework.Results;
namespace Musaca.Web.Controllers
{
public class UsersController : Controller
{
private readonly IUsersService usersService;
private readonly IOrdersService ordersService;
public UsersController(IUsersService usersService, IOrdersService ordersService)
{
this.usersService = usersService;
this.ordersService = ordersService;
}
public IActionResult Login()
{
return View();
}
[HttpPost]
public IActionResult Login(LoginInputModel model)
{
User user = usersService.GetUserOrNull(model.Username, model.Password);
if (user == null)
{
ModelState.Add("Username", "Invalid username or password!");
return Redirect("/Users/Login");
}
this.SignIn(user.Id, user.Username, user.Email);
return Redirect("/");
}
public IActionResult Register()
{
return View();
}
[HttpPost]
public IActionResult Register(RegisterInputModel model)
{
if (!ModelState.IsValid)
{
return Redirect("/Users/Register");
}
if (model.Password != model.ConfirmPassword)
{
ModelState.Add(string.Empty, "The passwords must match");
return Redirect("/Users/Register");
}
if (usersService.UserExists(model.Username))
{
ModelState.Add(string.Empty, "User with the same username already exists!");
return Redirect("/Users/Register");
}
User user = model.MapTo<User>();
string userId = usersService.CreateUser(user);
this.SignIn(userId, model.Username, model.Email);
return Redirect("/");
}
public IActionResult Logout()
{
SignOut();
return Redirect("/");
}
[Authorize]
public IActionResult Profile()
{
var ordres = ordersService.GetCashierCompletedOrders(this.User.Id);
return View(ordres);
}
}
}
| 22.375 | 82 | 0.710513 | [
"MIT"
] | NaskoVasilev/CSharp-MVC-Framework | MvcFramework/Apps/Musaca/Musaca.Web/Controllers/UsersController.cs | 1,971 | C# |
using Approve.Common;
using Approve.RuleApp;
using Approve.RuleCenter;
using ProjectData;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
public partial class JSDW_ApplyXZYJS_Report : System.Web.UI.Page
{
private RCenter rc = new RCenter();
private ProjectDB db = new ProjectDB();
private RApp ra = new RApp();
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
if (!string.IsNullOrEmpty(FIsApprove))
{
if (FIsApprove == "1")
{
btnSave.Enabled = false;
}
}
showInfo();
}
}
public void showInfo()
{
string guid = fAppId;
if (!string.IsNullOrEmpty(guid))
{
var appList = db.CF_App_List.FirstOrDefault(x => x.FId == guid);
if (appList != null)
{
t_FYear.Text = appList.FYear.ToString();
t_FName.Text = appList.FName;
}
if (!string.IsNullOrEmpty(YJS_ID))
{
string sql = "select top 1 XZMC,XMSD,XMSDMC,SBBM,IsAudit from YW_XZYJS where ID='" + YJS_ID + "'";
DataTable table = rc.GetTable(sql);
if (table != null && table.Rows.Count > 0)
{
DataRow row = table.Rows[0];
hfIsAudit.Value = row["IsAudit"].ToString();
t_XZMC.Text = row["XZMC"].ToString();
DataTable dt = ra.GetCanReportDeptXM(row["XMSD"].ToString(), "1122", appList.FManageTypeId.Value.ToString(), ComFunction.GetDefaultDept());
ddlLevel.DataSource = dt;
ddlLevel.DataTextField = "fname";
ddlLevel.DataValueField = "fnumber";
ddlLevel.DataBind();
if (!string.IsNullOrEmpty(row["SBBM"].ToString()))
ddlLevel.SelectedValue = row["SBBM"].ToString();
}
}
}
}
protected void btnSave_Click(object sender, EventArgs e)
{
pageTool tool = new pageTool(this.Page);
if (hfIsAudit.Value != "1")//验证通过
{
tool.showMessage("上报信息未完善，请完善后提交");
return;
}
string fDeptNumber = ComFunction.GetDefaultDept();
if (fDeptNumber == null || fDeptNumber == "")
{
tool.showMessage("系统出错,请配置默认管理部门");
return;
}
btnSave.Text = "请稍后...";
btnSave.Enabled = false;
DateTime dTime = DateTime.Now;
//设计端业务
CF_App_List appList = db.CF_App_List.Where(t => t.FId == fAppId).FirstOrDefault();
SortedList[] sl = new SortedList[1];
if (appList != null)
{
sl[0] = new SortedList();
sl[0].Add("FID", appList.FId);
sl[0].Add("FAppId", appList.FId);
sl[0].Add("FBaseInfoId", appList.FBaseinfoId);
sl[0].Add("FManageTypeId", appList.FManageTypeId);
sl[0].Add("FListId", "1930100");
sl[0].Add("FTypeId", "1930100");
sl[0].Add("FLevelId", "1930100");
sl[0].Add("FIsPrime", 0);
sl[0].Add("FAppTime", DateTime.Now);
sl[0].Add("FIsNew", 0);
sl[0].Add("FIsBase", 0);
sl[0].Add("FIsTemp", 0);
sl[0].Add("FUpDept", ddlLevel.SelectedValue);
sl[0].Add("FEmpId", appList.FLinkId);//CF_Prj_Data.FID
sl[0].Add("FEmpName", t_XZMC.Text.Trim());
sl[0].Add("FLeadId", "");//建设单位ID（这里没有）
sl[0].Add("FLeadName", "");
StringBuilder sb = new StringBuilder();
sb.Append("update CF_App_List set FUpDeptId=" + ddlLevel.SelectedValue + ",");
sb.Append("ftime=getdate(),FState=1,FReportDate=getdate(),FIsDeleted=0 where fid = '" + fAppId + "';");
sb.AppendFormat("update YW_XZYJS set SBBM='{0}',SBRQ='{2}' where ID='{1}';", ddlLevel.SelectedValue, YJS_ID,DateTime.Now);
rc.PExcute(sb.ToString());
}
else
{
btnSave.Enabled = true;
tool.showMessage("该业务数据有误，请重新申请！");
return;
}
if (ra.EntStartProcessKCSJ(appList.FBaseinfoId, fAppId, appList.FYear.ToString(), DateTime.Now.Month.ToString(), "1122", fDeptNumber, ddlLevel.SelectedValue, sl))
{
Session["FIsApprove"] = 1;
tool.showMessageAndRunFunction("提交成功！", "location.href=location.href");
}else
btnSave.Enabled = true;
}
public void readOnly()
{
btnSave.Enabled = false;
}
public string YJS_ID
{
get
{
return Request.QueryString["YJS_GUID"];
}
}
private string FIsApprove
{
get
{
string value = Session["FIsApprove"] == null ? "" : Session["FIsApprove"].ToString();
if (string.IsNullOrEmpty(value))
return "0";
return value;
}
}
private string fAppId {
get {
return Request.QueryString["fAppId"];
}
}
} | 35.165563 | 170 | 0.526177 | [
"MIT"
] | coojee2012/pm3 | SurveyDesign/JSDW/ApplyXZYJS/Report.aspx.cs | 5,448 | C# |
namespace AnyClone.Tests.Extensions
{
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
public static class CollectionExtensions
{
/// <summary>
/// Compare any enumerable to another enumerable
/// </summary>
/// <param name="aCollection"></param>
/// <param name="aSecond"></param>
/// <returns></returns>
public static bool EnumerableEqual(this IEnumerable aCollection, IEnumerable aSecond)
{
// optimal way to compare 2 multidimensional arrays is to flatten both of them then compare the entire set
var linearList = new List<int>();
var otherLinearList = new List<int>();
IEnumerator enumerator = aCollection.GetEnumerator();
IEnumerator secondEnumerator = aSecond.GetEnumerator();
try
{
while (enumerator.MoveNext() && secondEnumerator.MoveNext())
{
linearList.Add((int)enumerator.Current);
otherLinearList.Add((int)secondEnumerator.Current);
}
enumerator.Reset();
secondEnumerator.Reset();
return linearList.SequenceEqual(otherLinearList);
}
catch (Exception)
{
return false;
}
}
}
}
| 29.878049 | 112 | 0.64898 | [
"Unlicense"
] | ApocDev/blazor-state | Tests/TestApp/Client/Extensions/CollectionExtensions.cs | 1,225 | C# |
#region License
/*
* Copyright 2018 JanusGraph.Net Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
using System.Text.Json;
using JanusGraph.Net.IO.GraphSON;
using Xunit;
namespace JanusGraph.Net.UnitTest.IO.GraphSON
{
public class RelationIdentifierSerializationSymmetricyTests
{
[Fact]
public void SerializeAndDeserialize_ValidRelationIdentifier_SameRelationIdentifier()
{
var relationIdentifier = new RelationIdentifier("someRelationId");
var writer = JanusGraphSONWriterBuilder.Build().Create();
var reader = JanusGraphSONReaderBuilder.Build().Create();
var graphSon = writer.WriteObject(relationIdentifier);
var readRelationIdentifier = reader.ToObject(JsonDocument.Parse(graphSon).RootElement);
Assert.Equal(relationIdentifier, readRelationIdentifier);
}
}
} | 33.833333 | 99 | 0.724138 | [
"ECL-2.0",
"Apache-2.0"
] | JanusGraph/janusgraph-dotnet | test/JanusGraph.Net.UnitTest/IO/GraphSON/RelationIdentifierSerializationSymmetricyTests.cs | 1,423 | C# |
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.ComponentModel;
using System.Security;
namespace System.Management
{
/// <summary>
/// <para>Describes the authentication level to be used to connect to WMI. This is used for the COM connection to WMI.</para>
/// </summary>
public enum AuthenticationLevel
{
/// <summary>
/// <para>The default COM authentication level. WMI uses the default Windows Authentication setting.</para>
/// </summary>
Default = 0,
/// <summary>
/// <para> No COM authentication.</para>
/// </summary>
None = 1,
/// <summary>
/// <para> Connect-level COM authentication.</para>
/// </summary>
Connect = 2,
/// <summary>
/// <para> Call-level COM authentication.</para>
/// </summary>
Call = 3,
/// <summary>
/// <para> Packet-level COM authentication.</para>
/// </summary>
Packet = 4,
/// <summary>
/// <para>Packet Integrity-level COM authentication.</para>
/// </summary>
PacketIntegrity = 5,
/// <summary>
/// <para>Packet Privacy-level COM authentication.</para>
/// </summary>
PacketPrivacy = 6,
/// <summary>
/// <para>The default COM authentication level. WMI uses the default Windows Authentication setting.</para>
/// </summary>
Unchanged = -1
}
/// <summary>
/// <para>Describes the impersonation level to be used to connect to WMI.</para>
/// </summary>
public enum ImpersonationLevel
{
/// <summary>
/// <para>Default impersonation.</para>
/// </summary>
Default = 0,
/// <summary>
/// <para> Anonymous COM impersonation level that hides the
/// identity of the caller. Calls to WMI may fail
/// with this impersonation level.</para>
/// </summary>
Anonymous = 1,
/// <summary>
/// <para> Identify-level COM impersonation level that allows objects
/// to query the credentials of the caller. Calls to
/// WMI may fail with this impersonation level.</para>
/// </summary>
Identify = 2,
/// <summary>
/// <para> Impersonate-level COM impersonation level that allows
/// objects to use the credentials of the caller. This is the recommended impersonation level for WMI calls.</para>
/// </summary>
Impersonate = 3,
/// <summary>
/// <para> Delegate-level COM impersonation level that allows objects
/// to permit other objects to use the credentials of the caller. This
/// level, which will work with WMI calls but may constitute an unnecessary
/// security risk, is supported only under Windows 2000.</para>
/// </summary>
Delegate = 4
}
/// <summary>
/// <para>Describes the possible effects of saving an object to WMI when
/// using <see cref='System.Management.ManagementObject.Put()'/>.</para>
/// </summary>
public enum PutType
{
/// <summary>
/// <para> Invalid Type </para>
/// </summary>
None = 0,
/// <summary>
/// <para> Updates an existing object
/// only; does not create a new object.</para>
/// </summary>
UpdateOnly = 1,
/// <summary>
/// <para> Creates an object only;
/// does not update an existing object.</para>
/// </summary>
CreateOnly = 2,
/// <summary>
/// <para> Saves the object, whether
/// updating an existing object or creating a new object.</para>
/// </summary>
UpdateOrCreate = 3
}
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
/// <summary>
/// <para>
/// Provides an abstract base class for all Options objects.</para>
/// <para>Options objects are used to customize different management operations. </para>
/// <para>Use one of the Options classes derived from this class, as
/// indicated by the signature of the operation being performed.</para>
/// </summary>
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
[TypeConverter(typeof(ExpandableObjectConverter))]
public abstract class ManagementOptions : ICloneable
{
/// <summary>
/// <para> Specifies an infinite timeout.</para>
/// </summary>
public static readonly TimeSpan InfiniteTimeout = TimeSpan.MaxValue;
internal int flags;
internal ManagementNamedValueCollection context;
internal TimeSpan timeout;
//Used when any public property on this object is changed, to signal
//to the containing object that it needs to be refreshed.
internal event IdentifierChangedEventHandler IdentifierChanged;
//Fires IdentifierChanged event
internal void FireIdentifierChanged()
{
IdentifierChanged?.Invoke(this, null);
}
//Called when IdentifierChanged() event fires
internal void HandleIdentifierChange(object sender,
IdentifierChangedEventArgs args)
{
//Something inside ManagementOptions changed, we need to fire an event
//to the parent object
FireIdentifierChanged();
}
internal int Flags
{
get { return flags; }
set { flags = value; }
}
/// <summary>
/// <para> Gets or sets a WMI context object. This is a
/// name-value pairs list to be passed through to a WMI provider that supports
/// context information for customized operation.</para>
/// </summary>
/// <value>
/// <para>A name-value pairs list to be passed through to a WMI provider that
/// supports context information for customized operation.</para>
/// </value>
public ManagementNamedValueCollection Context
{
get
{
if (context == null)
return context = new ManagementNamedValueCollection();
else
return context;
}
set
{
ManagementNamedValueCollection oldContext = context;
if (null != value)
context = (ManagementNamedValueCollection)value.Clone();
else
context = new ManagementNamedValueCollection();
if (null != oldContext)
oldContext.IdentifierChanged -= new IdentifierChangedEventHandler(HandleIdentifierChange);
//register for change events in this object
context.IdentifierChanged += new IdentifierChangedEventHandler(HandleIdentifierChange);
//the context property has changed so act like we fired the event
HandleIdentifierChange(this, null);
}
}
/// <summary>
/// <para>Gets or sets the timeout to apply to the operation.
/// Note that for operations that return collections, this timeout applies to the
/// enumeration through the resulting collection, not the operation itself
/// (the <see cref='System.Management.EnumerationOptions.ReturnImmediately'/>
/// property is used for the latter).</para>
/// This property is used to indicate that the operation should be performed semisynchronously.
/// </summary>
/// <value>
/// <para>The default value for this property is <see cref='System.Management.ManagementOptions.InfiniteTimeout'/>
/// , which means the operation will block.
/// The value specified must be positive.</para>
/// </value>
public TimeSpan Timeout
{
get
{ return timeout; }
set
{
//Timespan allows for negative values, but we want to make sure it's positive here...
if (value.Ticks < 0)
throw new ArgumentOutOfRangeException(nameof(value));
timeout = value;
FireIdentifierChanged();
}
}
internal ManagementOptions() : this(null, InfiniteTimeout) { }
internal ManagementOptions(ManagementNamedValueCollection context, TimeSpan timeout) : this(context, timeout, 0) { }
internal ManagementOptions(ManagementNamedValueCollection context, TimeSpan timeout, int flags)
{
this.flags = flags;
if (context != null)
this.Context = context;
else
this.context = null;
this.Timeout = timeout;
}
internal IWbemContext GetContext()
{
if (context != null)
return context.GetContext();
else
return null;
}
// We do not expose this publicly; instead the flag is set automatically
// when making an async call if we detect that someone has requested to
// listen for status messages.
internal bool SendStatus
{
get
{ return (((Flags & (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_SEND_STATUS) != 0) ? true : false); }
set
{
Flags = (value == false) ? (Flags & (int)~tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_SEND_STATUS) :
(Flags | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_SEND_STATUS);
}
}
/// <summary>
/// <para> Returns a copy of the object.</para>
/// </summary>
/// <returns>
/// <para>The cloned object.</para>
/// </returns>
public abstract object Clone();
}
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
/// <summary>
/// <para>Provides a base class for query and enumeration-related options
/// objects.</para>
/// <para>Use this class to customize enumeration of management
/// objects, traverse management object relationships, or query for
/// management objects.</para>
/// </summary>
/// <example>
/// <code lang='C#'>using System;
/// using System.Management;
///
/// // This example demonstrates how to enumerate all top-level WMI classes
/// // and subclasses in root/cimv2 namespace.
/// class Sample_EnumerationOptions
/// {
/// public static int Main(string[] args) {
/// ManagementClass newClass = new ManagementClass();
/// EnumerationOptions options = new EnumerationOptions();
/// options.EnumerateDeep = false;
/// foreach (ManagementObject o in newClass.GetSubclasses(options)) {
/// Console.WriteLine(o["__Class"]);
/// }
/// return 0;
/// }
/// }
/// </code>
/// <code lang='VB'>Imports System
/// Imports System.Management
///
/// ' This example demonstrates how to enumerate all top-level WMI classes
/// ' and subclasses in root/cimv2 namespace.
/// Class Sample_EnumerationOptions
/// Overloads Public Shared Function Main(args() As String) As Integer
/// Dim newClass As New ManagementClass()
/// Dim options As New EnumerationOptions()
/// options.EnumerateDeep = False
/// Dim o As ManagementObject
/// For Each o In newClass.GetSubclasses(options)
/// Console.WriteLine(o("__Class"))
/// Next o
/// Return 0
/// End Function
/// End Class
/// </code>
/// </example>
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
public class EnumerationOptions : ManagementOptions
{
private int blockSize;
/// <summary>
/// <para>Gets or sets a value indicating whether the invoked operation should be
/// performed in a synchronous or semisynchronous fashion. If this property is set
/// to <see langword='true'/>, the enumeration is invoked and the call returns immediately. The actual
/// retrieval of the results will occur when the resulting collection is walked.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if the invoked operation should
/// be performed in a synchronous or semisynchronous fashion; otherwise,
/// <see langword='false'/>. The default value is <see langword='true'/>.</para>
/// </value>
public bool ReturnImmediately
{
get { return (((Flags & (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_RETURN_IMMEDIATELY) != 0) ? true : false); }
set
{
Flags = (value == false) ? (Flags & (int)~tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_RETURN_IMMEDIATELY) :
(Flags | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_RETURN_IMMEDIATELY);
}
}
/// <summary>
/// <para> Gets or sets the block size
/// for block operations. When enumerating through a collection, WMI will return results in
/// groups of the specified size.</para>
/// </summary>
/// <value>
/// <para>The default value is 1.</para>
/// </value>
public int BlockSize
{
get { return blockSize; }
set
{
//Unfortunately BlockSize was defined as int, but valid values are only > 0
if (value <= 0)
throw new ArgumentOutOfRangeException(nameof(value));
blockSize = value;
}
}
/// <summary>
/// <para>Gets or sets a value indicating whether the collection is assumed to be
/// rewindable. If <see langword='true'/>, the objects in the
/// collection will be kept available for multiple enumerations. If
/// <see langword='false'/>, the collection
/// can only be enumerated one time.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if the collection is assumed to
/// be rewindable; otherwise, <see langword='false'/>. The default value is
/// <see langword='true'/>.</para>
/// </value>
/// <remarks>
/// <para>A rewindable collection is more costly in memory
/// consumption as all the objects need to be kept available at the same time.
/// In a collection defined as non-rewindable, the objects are discarded after being returned
/// in the enumeration.</para>
/// </remarks>
public bool Rewindable
{
get { return (((Flags & (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_FORWARD_ONLY) != 0) ? false : true); }
set
{
Flags = value ? (Flags & (int)~tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_FORWARD_ONLY) :
(Flags | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_FORWARD_ONLY);
}
}
/// <summary>
/// <para> Gets or sets a value indicating whether the objects returned from
/// WMI should contain amended information. Typically, amended information is localizable
/// information attached to the WMI object, such as object and property
/// descriptions.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if the objects returned from WMI
/// should contain amended information; otherwise, <see langword='false'/>. The
/// default value is <see langword='false'/>.</para>
/// </value>
/// <remarks>
/// <para>If descriptions and other amended information are not of
/// interest, setting this property to <see langword='false'/>
/// is more
/// efficient.</para>
/// </remarks>
public bool UseAmendedQualifiers
{
get { return (((Flags & (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS) != 0) ? true : false); }
set
{
Flags = value ? (Flags | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS) :
(Flags & (int)~tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS);
}
}
/// <summary>
/// <para>Gets or sets a value indicating whether to the objects returned should have
/// locatable information in them. This ensures that the system properties, such as
/// <see langword='__PATH'/>, <see langword='__RELPATH'/>, and
/// <see langword='__SERVER'/>, are non-NULL. This flag can only be used in queries,
/// and is ignored in enumerations.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if WMI
/// should ensure all returned objects have valid paths; otherwise,
/// <see langword='false'/>. The default value is <see langword='false'/>.</para>
/// </value>
public bool EnsureLocatable
{
get
{ return (((Flags & (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_ENSURE_LOCATABLE) != 0) ? true : false); }
set
{
Flags = value ? (Flags | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_ENSURE_LOCATABLE) :
(Flags & (int)~tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_ENSURE_LOCATABLE);
}
}
/// <summary>
/// <para>Gets or sets a value indicating whether the query should return a
/// prototype of the result set instead of the actual results. This flag is used for
/// prototyping.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if the
/// query should return a prototype of the result set instead of the actual results;
/// otherwise, <see langword='false'/>. The default value is
/// <see langword='false'/>.</para>
/// </value>
public bool PrototypeOnly
{
get
{ return (((Flags & (int)tag_WBEM_QUERY_FLAG_TYPE.WBEM_FLAG_PROTOTYPE) != 0) ? true : false); }
set
{
Flags = value ? (Flags | (int)tag_WBEM_QUERY_FLAG_TYPE.WBEM_FLAG_PROTOTYPE) :
(Flags & (int)~tag_WBEM_QUERY_FLAG_TYPE.WBEM_FLAG_PROTOTYPE);
}
}
/// <summary>
/// <para> Gets or sets a value indicating whether direct access to the WMI provider is requested for the specified class,
/// without any regard to its base class or derived classes.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if only
/// objects of the specified class should be received, without regard to derivation
/// or inheritance; otherwise, <see langword='false'/>. The default value is
/// <see langword='false'/>. </para>
/// </value>
public bool DirectRead
{
get
{ return (((Flags & (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_DIRECT_READ) != 0) ? true : false); }
set
{
Flags = value ? (Flags | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_DIRECT_READ) :
(Flags & (int)~tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_DIRECT_READ);
}
}
/// <summary>
/// <para> Gets or sets a value indicating whether recursive enumeration is requested
/// into all classes derived from the specified base class. If
/// <see langword='false'/>, only immediate derived
/// class members are returned.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if recursive enumeration is requested
/// into all classes derived from the specified base class; otherwise,
/// <see langword='false'/>. The default value is <see langword='false'/>.</para>
/// </value>
public bool EnumerateDeep
{
get
{ return (((Flags & (int)tag_WBEM_QUERY_FLAG_TYPE.WBEM_FLAG_SHALLOW) != 0) ? false : true); }
set
{
Flags = (value == false) ? (Flags | (int)tag_WBEM_QUERY_FLAG_TYPE.WBEM_FLAG_SHALLOW) :
(Flags & (int)~tag_WBEM_QUERY_FLAG_TYPE.WBEM_FLAG_SHALLOW);
}
}
//default constructor
/// <overload>
/// Initializes a new instance
/// of the <see cref='System.Management.EnumerationOptions'/> class.
/// </overload>
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.EnumerationOptions'/>
/// class with default values (see the individual property descriptions
/// for what the default values are). This is the default constructor. </para>
/// </summary>
public EnumerationOptions() : this(null, InfiniteTimeout, 1, true, true, false, false, false, false, false) { }
//Constructor that specifies flags as individual values - we need to set the flags accordingly !
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.EnumerationOptions'/> class to be used for queries or enumerations,
/// allowing the user to specify values for the different options.</para>
/// </summary>
/// <param name='context'>The options context object containing provider-specific information that can be passed through to the provider.</param>
/// <param name=' timeout'>The timeout value for enumerating through the results.</param>
/// <param name=' blockSize'>The number of items to retrieve at one time from WMI.</param>
/// <param name=' rewindable'><see langword='true'/> to specify whether the result set is rewindable (=allows multiple traversal or one-time); otherwise, <see langword='false'/>.</param>
/// <param name=' returnImmediatley'><see langword='true'/> to specify whether the operation should return immediately (semi-sync) or block until all results are available; otherwise, <see langword='false'/> .</param>
/// <param name=' useAmendedQualifiers'><see langword='true'/> to specify whether the returned objects should contain amended (locale-aware) qualifiers; otherwise, <see langword='false'/> .</param>
/// <param name=' ensureLocatable'><see langword='true'/> to specify to WMI that it should ensure all returned objects have valid paths; otherwise, <see langword='false'/> .</param>
/// <param name=' prototypeOnly'><see langword='true'/> to return a prototype of the result set instead of the actual results; otherwise, <see langword='false'/> .</param>
/// <param name=' directRead'><see langword='true'/> to retrieve objects of only the specified class only or from derived classes as well; otherwise, <see langword='false'/> .</param>
/// <param name=' enumerateDeep'><see langword='true'/> to specify recursive enumeration in subclasses; otherwise, <see langword='false'/> .</param>
public EnumerationOptions(
ManagementNamedValueCollection context,
TimeSpan timeout,
int blockSize,
bool rewindable,
bool returnImmediatley,
bool useAmendedQualifiers,
bool ensureLocatable,
bool prototypeOnly,
bool directRead,
bool enumerateDeep) : base(context, timeout)
{
BlockSize = blockSize;
Rewindable = rewindable;
ReturnImmediately = returnImmediatley;
UseAmendedQualifiers = useAmendedQualifiers;
EnsureLocatable = ensureLocatable;
PrototypeOnly = prototypeOnly;
DirectRead = directRead;
EnumerateDeep = enumerateDeep;
}
/// <summary>
/// <para> Returns a copy of the object.</para>
/// </summary>
/// <returns>
/// <para>The cloned object.</para>
/// </returns>
public override object Clone()
{
ManagementNamedValueCollection newContext = null;
if (null != Context)
newContext = (ManagementNamedValueCollection)Context.Clone();
return new EnumerationOptions(newContext, Timeout, blockSize, Rewindable,
ReturnImmediately, UseAmendedQualifiers, EnsureLocatable, PrototypeOnly, DirectRead, EnumerateDeep);
}
}//EnumerationOptions
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
/// <summary>
/// <para> Specifies options for management event watching.</para>
/// <para>Use this class to customize subscriptions for watching management events. </para>
/// </summary>
/// <example>
/// <code lang='C#'>using System;
/// using System.Management;
///
/// // This example demonstrates how to listen to an event using ManagementEventWatcher object.
/// class Sample_EventWatcherOptions
/// {
/// public static int Main(string[] args) {
/// ManagementClass newClass = new ManagementClass();
/// newClass["__CLASS"] = "TestDeletionClass";
/// newClass.Put();
///
/// EventWatcherOptions options = new EventWatcherOptions();
/// ManagementEventWatcher watcher = new ManagementEventWatcher(null,
/// new WqlEventQuery("__classdeletionevent"),
/// options);
/// MyHandler handler = new MyHandler();
/// watcher.EventArrived += new EventArrivedEventHandler(handler.Arrived);
/// watcher.Start();
///
/// // Delete class to trigger event
/// newClass.Delete();
///
/// //For the purpose of this example, we will wait
/// // two seconds before main thread terminates.
/// System.Threading.Thread.Sleep(2000);
///
/// watcher.Stop();
///
/// return 0;
/// }
///
/// public class MyHandler
/// {
/// public void Arrived(object sender, EventArrivedEventArgs e) {
/// Console.WriteLine("Class Deleted= " +
/// ((ManagementBaseObject)e.NewEvent["TargetClass"])["__CLASS"]);
/// }
/// }
/// }
/// </code>
/// <code lang='VB'>Imports System
/// Imports System.Management
///
/// ' This example demonstrates how to listen to an event using the ManagementEventWatcher object.
/// Class Sample_EventWatcherOptions
/// Public Shared Sub Main()
/// Dim newClass As New ManagementClass()
/// newClass("__CLASS") = "TestDeletionClass"
/// newClass.Put()
///
/// Dim options As _
/// New EventWatcherOptions()
/// Dim watcher As New ManagementEventWatcher( _
/// Nothing, _
/// New WqlEventQuery("__classdeletionevent"), _
/// options)
/// Dim handler As New MyHandler()
/// AddHandler watcher.EventArrived, AddressOf handler.Arrived
/// watcher.Start()
///
/// ' Delete class to trigger event
/// newClass.Delete()
///
/// ' For the purpose of this example, we will wait
/// ' two seconds before main thread terminates.
/// System.Threading.Thread.Sleep(2000)
/// watcher.Stop()
/// End Sub
///
/// Public Class MyHandler
/// Public Sub Arrived(sender As Object, e As EventArrivedEventArgs)
/// Console.WriteLine("Class Deleted = " & _
/// CType(e.NewEvent("TargetClass"), ManagementBaseObject)("__CLASS"))
/// End Sub
/// End Class
/// End Class
/// </code>
/// </example>
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
public class EventWatcherOptions : ManagementOptions
{
private int blockSize = 1;
/// <summary>
/// <para>Gets or sets the block size for block operations. When waiting for events, this
/// value specifies how many events to wait for before returning.</para>
/// </summary>
/// <value>
/// <para>The default value is 1.</para>
/// </value>
public int BlockSize
{
get { return blockSize; }
set
{
blockSize = value;
FireIdentifierChanged();
}
}
/// <overload>
/// <para>Initializes a new instance of the <see cref='System.Management.EventWatcherOptions'/> class. </para>
/// </overload>
/// <summary>
/// <para> Initializes a new instance of the <see cref='System.Management.EventWatcherOptions'/> class for event watching, using default values.
/// This is the default constructor.</para>
/// </summary>
public EventWatcherOptions()
: this(null, InfiniteTimeout, 1) { }
/// <summary>
/// <para> Initializes a new instance of the <see cref='System.Management.EventWatcherOptions'/> class with the given
/// values.</para>
/// </summary>
/// <param name='context'>The options context object containing provider-specific information to be passed through to the provider. </param>
/// <param name=' timeout'>The timeout to wait for the next events.</param>
/// <param name=' blockSize'>The number of events to wait for in each block.</param>
public EventWatcherOptions(ManagementNamedValueCollection context, TimeSpan timeout, int blockSize)
: base(context, timeout)
{
Flags = (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_RETURN_IMMEDIATELY | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_FORWARD_ONLY;
BlockSize = blockSize;
}
/// <summary>
/// <para> Returns a copy of the object.</para>
/// </summary>
/// <returns>
/// The cloned object.
/// </returns>
public override object Clone()
{
ManagementNamedValueCollection newContext = null;
if (null != Context)
newContext = (ManagementNamedValueCollection)Context.Clone();
return new EventWatcherOptions(newContext, Timeout, blockSize);
}
}//EventWatcherOptions
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
/// <summary>
/// <para> Specifies options for getting a management object.</para>
/// Use this class to customize retrieval of a management object.
/// </summary>
/// <example>
/// <code lang='C#'>using System;
/// using System.Management;
///
/// // This example demonstrates how to set a timeout value and list
/// // all amended qualifiers in a ManagementClass object.
/// class Sample_ObjectGetOptions
/// {
/// public static int Main(string[] args) {
/// // Request amended qualifiers
/// ObjectGetOptions options =
/// new ObjectGetOptions(null, new TimeSpan(0,0,0,5), true);
/// ManagementClass diskClass =
/// new ManagementClass("root/cimv2", "Win32_Process", options);
/// foreach (QualifierData qualifier in diskClass.Qualifiers) {
/// Console.WriteLine(qualifier.Name + ":" + qualifier.Value);
/// }
/// return 0;
/// }
/// }
/// </code>
/// <code lang='VB'>Imports System
/// Imports System.Management
///
/// ' This example demonstrates how to set a timeout value and list
/// ' all amended qualifiers in a ManagementClass object.
/// Class Sample_ObjectGetOptions
/// Overloads Public Shared Function Main(args() As String) As Integer
/// ' Request amended qualifiers
/// Dim options As _
/// New ObjectGetOptions(Nothing, New TimeSpan(0, 0, 0, 5), True)
/// Dim diskClass As New ManagementClass( _
/// "root/cimv2", _
/// "Win32_Process", _
/// options)
/// Dim qualifier As QualifierData
/// For Each qualifier In diskClass.Qualifiers
/// Console.WriteLine(qualifier.Name & ":" & qualifier.Value)
/// Next qualifier
/// Return 0
/// End Function
/// End Class
/// </code>
/// </example>
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
public class ObjectGetOptions : ManagementOptions
{
internal static ObjectGetOptions _Clone(ObjectGetOptions options)
{
return ObjectGetOptions._Clone(options, null);
}
internal static ObjectGetOptions _Clone(ObjectGetOptions options, IdentifierChangedEventHandler handler)
{
ObjectGetOptions optionsTmp;
if (options != null)
optionsTmp = new ObjectGetOptions(options.context, options.timeout, options.UseAmendedQualifiers);
else
optionsTmp = new ObjectGetOptions();
// Wire up change handler chain. Use supplied handler, if specified;
// otherwise, default to that of the path argument.
if (handler != null)
optionsTmp.IdentifierChanged += handler;
else if (options != null)
optionsTmp.IdentifierChanged += new IdentifierChangedEventHandler(options.HandleIdentifierChange);
return optionsTmp;
}
/// <summary>
/// <para> Gets or sets a value indicating whether the objects returned from WMI should
/// contain amended information. Typically, amended information is localizable information
/// attached to the WMI object, such as object and property descriptions.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if the objects returned from WMI
/// should contain amended information; otherwise, <see langword='false'/>. The
/// default value is <see langword='false'/>.</para>
/// </value>
public bool UseAmendedQualifiers
{
get { return (((Flags & (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS) != 0) ? true : false); }
set
{
Flags = value ? (Flags | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS) :
(Flags & (int)~tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS);
FireIdentifierChanged();
}
}
/// <overload>
/// <para>Initializes a new instance of the <see cref='System.Management.ObjectGetOptions'/> class.</para>
/// </overload>
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.ObjectGetOptions'/> class for getting a WMI object, using
/// default values. This is the default constructor.</para>
/// </summary>
public ObjectGetOptions() : this(null, InfiniteTimeout, false) { }
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.ObjectGetOptions'/> class for getting a WMI object, using the
/// specified provider-specific context.</para>
/// </summary>
/// <param name='context'>A provider-specific, named-value pairs context object to be passed through to the provider.</param>
public ObjectGetOptions(ManagementNamedValueCollection context) : this(context, InfiniteTimeout, false) { }
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.ObjectGetOptions'/> class for getting a WMI object,
/// using the given options values.</para>
/// </summary>
/// <param name='context'>A provider-specific, named-value pairs context object to be passed through to the provider.</param>
/// <param name=' timeout'>The length of time to let the operation perform before it times out. The default is <see cref='System.Management.ManagementOptions.InfiniteTimeout'/> .</param>
/// <param name=' useAmendedQualifiers'><see langword='true'/> if the returned objects should contain amended (locale-aware) qualifiers; otherwise, <see langword='false'/>. </param>
public ObjectGetOptions(ManagementNamedValueCollection context, TimeSpan timeout, bool useAmendedQualifiers) : base(context, timeout)
{
UseAmendedQualifiers = useAmendedQualifiers;
}
/// <summary>
/// <para> Returns a copy of the object.</para>
/// </summary>
/// <returns>
/// <para>The cloned object.</para>
/// </returns>
public override object Clone()
{
ManagementNamedValueCollection newContext = null;
if (null != Context)
newContext = (ManagementNamedValueCollection)Context.Clone();
return new ObjectGetOptions(newContext, Timeout, UseAmendedQualifiers);
}
}
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
/// <summary>
/// <para> Specifies options for committing management
/// object changes.</para>
/// <para>Use this class to customize how values are saved to a management object.</para>
/// </summary>
/// <example>
/// <code lang='C#'>using System;
/// using System.Management;
///
/// // This example demonstrates how to specify a PutOptions using
/// // PutOptions object when saving a ManagementClass object to
/// // the WMI respository.
/// class Sample_PutOptions
/// {
/// public static int Main(string[] args) {
/// ManagementClass newClass = new ManagementClass("root/default",
/// String.Empty,
/// null);
/// newClass["__Class"] = "class999xc";
///
/// PutOptions options = new PutOptions();
/// options.Type = PutType.UpdateOnly;
///
/// try
/// {
/// newClass.Put(options); //will fail if the class doesn't already exist
/// }
/// catch (ManagementException e)
/// {
/// Console.WriteLine("Couldn't update class: " + e.ErrorCode);
/// }
/// return 0;
/// }
/// }
/// </code>
/// <code lang='VB'>Imports System
/// Imports System.Management
///
/// ' This example demonstrates how to specify a PutOptions using
/// ' PutOptions object when saving a ManagementClass object to
/// ' WMI respository.
/// Class Sample_PutOptions
/// Overloads Public Shared Function Main(args() As String) As Integer
/// Dim newClass As New ManagementClass( _
/// "root/default", _
/// String.Empty, _
/// Nothing)
/// newClass("__Class") = "class999xc"
///
/// Dim options As New PutOptions()
/// options.Type = PutType.UpdateOnly 'will fail if the class doesn't already exist
///
/// Try
/// newClass.Put(options)
/// Catch e As ManagementException
/// Console.WriteLine("Couldn't update class: " & e.ErrorCode)
/// End Try
/// Return 0
/// End Function
/// End Class
/// </code>
/// </example>
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
public class PutOptions : ManagementOptions
{
/// <summary>
/// <para> Gets or sets a value indicating whether the objects returned from WMI should
/// contain amended information. Typically, amended information is localizable information
/// attached to the WMI object, such as object and property descriptions.</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if the objects returned from WMI
/// should contain amended information; otherwise, <see langword='false'/>. The
/// default value is <see langword='false'/>.</para>
/// </value>
public bool UseAmendedQualifiers
{
get { return (((Flags & (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS) != 0) ? true : false); }
set
{
Flags = value ? (Flags | (int)tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS) :
(Flags & (int)~tag_WBEM_GENERIC_FLAG_TYPE.WBEM_FLAG_USE_AMENDED_QUALIFIERS);
}
}
/// <summary>
/// <para>Gets or sets the type of commit to be performed for the object.</para>
/// </summary>
/// <value>
/// <para>The default value is <see cref='System.Management.PutType.UpdateOrCreate'/>.</para>
/// </value>
public PutType Type
{
get
{
return (((Flags & (int)tag_WBEM_CHANGE_FLAG_TYPE.WBEM_FLAG_UPDATE_ONLY) != 0) ? PutType.UpdateOnly :
((Flags & (int)tag_WBEM_CHANGE_FLAG_TYPE.WBEM_FLAG_CREATE_ONLY) != 0) ? PutType.CreateOnly :
PutType.UpdateOrCreate);
}
set
{
Flags |= value switch
{
PutType.UpdateOnly => (int)tag_WBEM_CHANGE_FLAG_TYPE.WBEM_FLAG_UPDATE_ONLY,
PutType.CreateOnly => (int)tag_WBEM_CHANGE_FLAG_TYPE.WBEM_FLAG_CREATE_ONLY,
PutType.UpdateOrCreate => (int)tag_WBEM_CHANGE_FLAG_TYPE.WBEM_FLAG_CREATE_OR_UPDATE,
_ => throw new ArgumentException(null, nameof(Type)),
};
}
}
/// <overload>
/// <para> Initializes a new instance of the <see cref='System.Management.PutOptions'/> class.</para>
/// </overload>
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.PutOptions'/> class for put operations, using default values.
/// This is the default constructor.</para>
/// </summary>
public PutOptions() : this(null, InfiniteTimeout, false, PutType.UpdateOrCreate) { }
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.PutOptions'/> class for committing a WMI object, using the
/// specified provider-specific context.</para>
/// </summary>
/// <param name='context'>A provider-specific, named-value pairs context object to be passed through to the provider.</param>
public PutOptions(ManagementNamedValueCollection context) : this(context, InfiniteTimeout, false, PutType.UpdateOrCreate) { }
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.PutOptions'/> class for committing a WMI object, using
/// the specified option values.</para>
/// </summary>
/// <param name='context'>A provider-specific, named-value pairs object to be passed through to the provider. </param>
/// <param name=' timeout'>The length of time to let the operation perform before it times out. The default is <see cref='System.Management.ManagementOptions.InfiniteTimeout'/> .</param>
/// <param name=' useAmendedQualifiers'><see langword='true'/> if the returned objects should contain amended (locale-aware) qualifiers; otherwise, <see langword='false'/>. </param>
/// <param name=' putType'> The type of commit to be performed (update or create).</param>
public PutOptions(ManagementNamedValueCollection context, TimeSpan timeout, bool useAmendedQualifiers, PutType putType) : base(context, timeout)
{
UseAmendedQualifiers = useAmendedQualifiers;
Type = putType;
}
/// <summary>
/// <para> Returns a copy of the object.</para>
/// </summary>
/// <returns>
/// <para>The cloned object.</para>
/// </returns>
public override object Clone()
{
ManagementNamedValueCollection newContext = null;
if (null != Context)
newContext = (ManagementNamedValueCollection)Context.Clone();
return new PutOptions(newContext, Timeout, UseAmendedQualifiers, Type);
}
}
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
/// <summary>
/// <para> Specifies options for deleting a management
/// object.</para>
/// </summary>
/// <example>
/// <code lang='C#'>using System;
/// using System.Management;
///
/// // This example demonstrates how to specify a timeout value
/// // when deleting a ManagementClass object.
/// class Sample_DeleteOptions
/// {
/// public static int Main(string[] args) {
/// ManagementClass newClass = new ManagementClass();
/// newClass["__CLASS"] = "ClassToDelete";
/// newClass.Put();
///
/// // Set deletion options: delete operation timeout value
/// DeleteOptions opt = new DeleteOptions(null, new TimeSpan(0,0,0,5));
///
/// ManagementClass dummyClassToDelete =
/// new ManagementClass("ClassToDelete");
/// dummyClassToDelete.Delete(opt);
///
/// return 0;
/// }
/// }
/// </code>
/// <code lang='VB'>Imports System
/// Imports System.Management
///
/// ' This sample demonstrates how to specify a timeout value
/// ' when deleting a ManagementClass object.
/// Class Sample_DeleteOptions
/// Overloads Public Shared Function Main(args() As String) As Integer
/// Dim newClass As New ManagementClass()
/// newClass("__CLASS") = "ClassToDelete"
/// newClass.Put()
///
/// ' Set deletion options: delete operation timeout value
/// Dim opt As New DeleteOptions(Nothing, New TimeSpan(0, 0, 0, 5))
///
/// Dim dummyClassToDelete As New ManagementClass("ClassToDelete")
/// dummyClassToDelete.Delete(opt)
/// Return 0
/// End Function
/// End Class
/// </code>
/// </example>
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
public class DeleteOptions : ManagementOptions
{
/// <overload>
/// <para>Initializes a new instance of the <see cref='System.Management.DeleteOptions'/> class.</para>
/// </overload>
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.DeleteOptions'/> class for the delete operation, using default values.
/// This is the default constructor.</para>
/// </summary>
public DeleteOptions() : base() { }
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.DeleteOptions'/> class for a delete operation, using
/// the specified values.</para>
/// </summary>
/// <param name='context'>A provider-specific, named-value pairs object to be passed through to the provider. </param>
/// <param name='timeout'>The length of time to let the operation perform before it times out. The default value is <see cref='System.Management.ManagementOptions.InfiniteTimeout'/> . Setting this parameter will invoke the operation semisynchronously.</param>
public DeleteOptions(ManagementNamedValueCollection context, TimeSpan timeout) : base(context, timeout) { }
/// <summary>
/// <para> Returns a copy of the object.</para>
/// </summary>
/// <returns>
/// <para>A cloned object.</para>
/// </returns>
public override object Clone()
{
ManagementNamedValueCollection newContext = null;
if (null != Context)
newContext = (ManagementNamedValueCollection)Context.Clone();
return new DeleteOptions(newContext, Timeout);
}
}
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
/// <summary>
/// <para> Specifies options for invoking a management method.</para>
/// <para>Use this class to customize the execution of a method on a management
/// object.</para>
/// </summary>
/// <example>
/// <code lang='C#'>using System;
/// using System.Management;
///
/// // This example demonstrates how to stop a system service.
/// class Sample_InvokeMethodOptions
/// {
/// public static int Main(string[] args) {
/// ManagementObject service =
/// new ManagementObject("win32_service=\"winmgmt\"");
/// InvokeMethodOptions options = new InvokeMethodOptions();
/// options.Timeout = new TimeSpan(0,0,0,5);
///
/// ManagementBaseObject outParams = service.InvokeMethod("StopService", null, options);
///
/// Console.WriteLine("Return Status = " + outParams["ReturnValue"]);
///
/// return 0;
/// }
/// }
/// </code>
/// <code lang='VB'>Imports System
/// Imports System.Management
///
/// ' This sample demonstrates how to stop a system service.
/// Class Sample_InvokeMethodOptions
/// Overloads Public Shared Function Main(args() As String) As Integer
/// Dim service As New ManagementObject("win32_service=""winmgmt""")
/// Dim options As New InvokeMethodOptions()
/// options.Timeout = New TimeSpan(0, 0, 0, 5)
///
/// Dim outParams As ManagementBaseObject = service.InvokeMethod( _
/// "StopService", _
/// Nothing, _
/// options)
///
/// Console.WriteLine("Return Status = " & _
/// outParams("ReturnValue").ToString())
///
/// Return 0
/// End Function
/// End Class
/// </code>
/// </example>
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
public class InvokeMethodOptions : ManagementOptions
{
/// <overload>
/// <para>Initializes a new instance of the <see cref='System.Management.InvokeMethodOptions'/> class.</para>
/// </overload>
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.InvokeMethodOptions'/> class for the <see cref='System.Management.ManagementObject.InvokeMethod(string, ManagementBaseObject, InvokeMethodOptions) '/> operation, using default values.
/// This is the default constructor.</para>
/// </summary>
public InvokeMethodOptions() : base() { }
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.InvokeMethodOptions'/> class for an invoke operation using
/// the specified values.</para>
/// </summary>
/// <param name=' context'>A provider-specific, named-value pairs object to be passed through to the provider. </param>
/// <param name='timeout'>The length of time to let the operation perform before it times out. The default value is <see cref='System.Management.ManagementOptions.InfiniteTimeout'/> . Setting this parameter will invoke the operation semisynchronously.</param>
public InvokeMethodOptions(ManagementNamedValueCollection context, TimeSpan timeout) : base(context, timeout) { }
/// <summary>
/// <para> Returns a copy of the object.</para>
/// </summary>
/// <returns>
/// <para>The cloned object.</para>
/// </returns>
public override object Clone()
{
ManagementNamedValueCollection newContext = null;
if (null != Context)
newContext = (ManagementNamedValueCollection)Context.Clone();
return new InvokeMethodOptions(newContext, Timeout);
}
}
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
/// <summary>
/// <para> Specifies all settings required to make a WMI connection.</para>
/// <para>Use this class to customize a connection to WMI made via a
/// ManagementScope object.</para>
/// </summary>
/// <example>
/// <code lang='C#'>using System;
/// using System.Management;
///
/// // This example demonstrates how to connect to remote machine
/// // using supplied credentials.
/// class Sample_ConnectionOptions
/// {
/// public static int Main(string[] args) {
/// ConnectionOptions options = new ConnectionOptions();
/// options.Username = "domain\\username";
/// options.Password = "password";
/// ManagementScope scope = new ManagementScope(
/// "\\\\servername\\root\\cimv2",
/// options);
/// try {
/// scope.Connect();
/// ManagementObject disk = new ManagementObject(
/// scope,
/// new ManagementPath("Win32_logicaldisk='c:'"),
/// null);
/// disk.Get();
/// }
/// catch (Exception e) {
/// Console.WriteLine("Failed to connect: " + e.Message);
/// }
/// return 0;
/// }
/// }
/// </code>
/// <code lang='VB'>Imports System
/// Imports System.Management
///
/// ' This example demonstrates how to connect to remote machine
/// ' using supplied credentials.
/// Class Sample_ConnectionOptions
/// Overloads Public Shared Function Main(args() As String) As Integer
/// Dim options As New ConnectionOptions()
/// options.Username = "domain\username"
/// options.Password = "password"
/// Dim scope As New ManagementScope("\\servername\root\cimv2", options)
/// Try
/// scope.Connect()
/// Dim disk As New ManagementObject(scope, _
/// New ManagementPath("Win32_logicaldisk='c:'"), Nothing)
/// disk.Get()
/// Catch e As UnauthorizedAccessException
/// Console.WriteLine(("Failed to connect: " + e.Message))
/// End Try
/// Return 0
/// End Function
/// End Class
/// </code>
/// </example>
//CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC//
public class ConnectionOptions : ManagementOptions
{
internal const string DEFAULTLOCALE = null;
internal const string DEFAULTAUTHORITY = null;
internal const ImpersonationLevel DEFAULTIMPERSONATION = ImpersonationLevel.Impersonate;
internal const AuthenticationLevel DEFAULTAUTHENTICATION = AuthenticationLevel.Unchanged;
internal const bool DEFAULTENABLEPRIVILEGES = false;
//Fields
private string locale;
private string username;
private SecureString securePassword;
private string authority;
private ImpersonationLevel impersonation;
private AuthenticationLevel authentication;
private bool enablePrivileges;
//
//Properties
//
/// <summary>
/// <para>Gets or sets the locale to be used for the connection operation.</para>
/// </summary>
/// <value>
/// <para>The default value is DEFAULTLOCALE.</para>
/// </value>
public string Locale
{
get { return locale ?? string.Empty; }
set
{
if (locale != value)
{
locale = value;
FireIdentifierChanged();
}
}
}
/// <summary>
/// <para>Gets or sets the user name to be used for the connection operation.</para>
/// </summary>
/// <value>
/// <para>Null if the connection will use the currently logged-on user; otherwise, a string representing the user name. The default value is null.</para>
/// </value>
/// <remarks>
/// <para>If the user name is from a domain other than the current
/// domain, the string may contain the domain name and user name, separated by a backslash:</para>
/// <c>
/// <para>string username = "EnterDomainHere\\EnterUsernameHere";</para>
/// </c>
/// </remarks>
public string Username
{
get { return username; }
set
{
if (username != value)
{
username = value;
FireIdentifierChanged();
}
}
}
/// <summary>
/// <para>Sets the password for the specified user. The value can be set, but not retrieved.</para>
/// </summary>
/// <value>
/// <para> The default value is null. If the user name is also
/// null, the credentials used will be those of the currently logged-on user.</para>
/// </value>
/// <remarks>
/// <para> A blank string ("") specifies a valid
/// zero-length password.</para>
/// </remarks>
public string Password
{
set
{
if (value != null)
{
if (securePassword == null)
{
securePassword = new SecureString();
for (int i = 0; i < value.Length; i++)
{
securePassword.AppendChar(value[i]);
}
}
else
{
SecureString tempStr = new SecureString();
for (int i = 0; i < value.Length; i++)
{
tempStr.AppendChar(value[i]);
}
securePassword.Clear();
securePassword = tempStr.Copy();
FireIdentifierChanged();
tempStr.Dispose();
}
}
else
{
if (securePassword != null)
{
securePassword.Dispose();
securePassword = null;
FireIdentifierChanged();
}
}
}
}
/// <summary>
/// <para>Sets the secure password for the specified user. The value can be set, but not retrieved.</para>
/// </summary>
/// <value>
/// <para> The default value is null. If the user name is also
/// null, the credentials used will be those of the currently logged-on user.</para>
/// </value>
/// <remarks>
/// <para> A blank securestring ("") specifies a valid
/// zero-length password.</para>
/// </remarks>
public SecureString SecurePassword
{
set
{
if (value != null)
{
if (securePassword == null)
{
securePassword = value.Copy();
}
else
{
securePassword.Clear();
securePassword = value.Copy();
FireIdentifierChanged();
}
}
else
{
if (securePassword != null)
{
securePassword.Dispose();
securePassword = null;
FireIdentifierChanged();
}
}
}
}
/// <summary>
/// <para>Gets or sets the authority to be used to authenticate the specified user.</para>
/// </summary>
/// <value>
/// <para>If not null, this property can contain the name of the
/// Windows NT/Windows 2000 domain in which to obtain the user to
/// authenticate.</para>
/// </value>
/// <remarks>
/// <para>
/// The property must be passed
/// as follows: If it begins with the string "Kerberos:", Kerberos
/// authentication will be used and this property should contain a Kerberos principal name. For
/// example, Kerberos:<principal name>.</para>
/// <para>If the property value begins with the string "NTLMDOMAIN:", NTLM
/// authentication will be used and the property should contain a NTLM domain name.
/// For example, NTLMDOMAIN:<domain name>. </para>
/// <para>If the property is null, NTLM authentication will be used and the NTLM domain
/// of the current user will be used.</para>
/// </remarks>
public string Authority
{
get { return authority ?? string.Empty; }
set
{
if (authority != value)
{
authority = value;
FireIdentifierChanged();
}
}
}
/// <summary>
/// <para>Gets or sets the COM impersonation level to be used for operations in this connection.</para>
/// </summary>
/// <value>
/// <para>The COM impersonation level to be used for operations in
/// this connection. The default value is <see cref='System.Management.ImpersonationLevel.Impersonate' qualify='true'/>, which indicates that the WMI provider can
/// impersonate the client when performing the requested operations in this connection.</para>
/// </value>
/// <remarks>
/// <para>The <see cref='System.Management.ImpersonationLevel.Impersonate' qualify='true'/> setting is advantageous when the provider is
/// a trusted application or service. It eliminates the need for the provider to
/// perform client identity and access checks for the requested operations. However,
/// note that if for some reason the provider cannot be trusted, allowing it to
/// impersonate the client may constitute a security threat. In such cases, it is
/// recommended that this property be set by the client to a lower value, such as
/// <see cref='System.Management.ImpersonationLevel. Identify' qualify='true'/>. Note that this may cause failure of the
/// provider to perform the requested operations, for lack of sufficient permissions
/// or inability to perform access checks.</para>
/// </remarks>
public ImpersonationLevel Impersonation
{
get { return impersonation; }
set
{
if (impersonation != value)
{
impersonation = value;
FireIdentifierChanged();
}
}
}
/// <summary>
/// <para>Gets or sets the COM authentication level to be used for operations in this connection.</para>
/// </summary>
/// <value>
/// <para>The COM authentication level to be used for operations
/// in this connection. The default value is <see cref='System.Management.AuthenticationLevel.Unchanged' qualify='true'/>, which indicates that the
/// client will use the authentication level requested by the server, according to
/// the standard DCOM negotiation process.</para>
/// </value>
/// <remarks>
/// <para>On Windows 2000 and below, the WMI service will request
/// Connect level authentication, while on Windows XP and higher it will request
/// Packet level authentication. If the client requires a specific authentication
/// setting, this property can be used to control the authentication level on this
/// particular connection. For example, the property can be set to <see cref='System.Management.AuthenticationLevel.PacketPrivacy' qualify='true'/>
/// if the
/// client requires all communication to be encrypted.</para>
/// </remarks>
public AuthenticationLevel Authentication
{
get { return authentication; }
set
{
if (authentication != value)
{
authentication = value;
FireIdentifierChanged();
}
}
}
/// <summary>
/// <para>Gets or sets a value indicating whether user privileges need to be enabled for
/// the connection operation. This property should only be used when the operation
/// performed requires a certain user privilege to be enabled
/// (for example, a machine reboot).</para>
/// </summary>
/// <value>
/// <para><see langword='true'/> if user privileges need to be
/// enabled for the connection operation; otherwise, <see langword='false'/>. The
/// default value is <see langword='false'/>.</para>
/// </value>
public bool EnablePrivileges
{
get { return enablePrivileges; }
set
{
if (enablePrivileges != value)
{
enablePrivileges = value;
FireIdentifierChanged();
}
}
}
//
//Constructors
//
//default
/// <overload>
/// <para>Initializes a new instance of the <see cref='System.Management.ConnectionOptions'/> class.</para>
/// </overload>
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.Management.ConnectionOptions'/> class for the connection operation, using default values. This is the
/// default constructor.</para>
/// </summary>
public ConnectionOptions() :
this(DEFAULTLOCALE, null, (string)null, DEFAULTAUTHORITY,
DEFAULTIMPERSONATION, DEFAULTAUTHENTICATION,
DEFAULTENABLEPRIVILEGES, null, InfiniteTimeout)
{ }
//parameterized
/// <summary>
/// <para> Initializes a new instance of the <see cref='System.Management.ConnectionOptions'/> class to be used for a WMI
/// connection, using the specified values.</para>
/// </summary>
/// <param name='locale'>The locale to be used for the connection.</param>
/// <param name=' username'>The user name to be used for the connection. If null, the credentials of the currently logged-on user are used.</param>
/// <param name=' password'>The password for the given user name. If the user name is also null, the credentials used will be those of the currently logged-on user.</param>
/// <param name=' authority'><para>The authority to be used to authenticate the specified user.</para></param>
/// <param name=' impersonation'>The COM impersonation level to be used for the connection.</param>
/// <param name=' authentication'>The COM authentication level to be used for the connection.</param>
/// <param name=' enablePrivileges'><see langword='true'/>to enable special user privileges; otherwise, <see langword='false'/> . This parameter should only be used when performing an operation that requires special Windows NT user privileges.</param>
/// <param name=' context'>A provider-specific, named value pairs object to be passed through to the provider.</param>
/// <param name=' timeout'>Reserved for future use.</param>
public ConnectionOptions(string locale,
string username, string password, string authority,
ImpersonationLevel impersonation, AuthenticationLevel authentication,
bool enablePrivileges,
ManagementNamedValueCollection context, TimeSpan timeout) : base(context, timeout)
{
if (locale != null)
this.locale = locale;
this.username = username;
this.enablePrivileges = enablePrivileges;
if (password != null)
{
this.securePassword = new SecureString();
for (int i = 0; i < password.Length; i++)
{
securePassword.AppendChar(password[i]);
}
}
if (authority != null)
this.authority = authority;
if (impersonation != 0)
this.impersonation = impersonation;
if (authentication != 0)
this.authentication = authentication;
}
//parameterized
/// <summary>
/// <para> Initializes a new instance of the <see cref='System.Management.ConnectionOptions'/> class to be used for a WMI
/// connection, using the specified values.</para>
/// </summary>
/// <param name='locale'>The locale to be used for the connection.</param>
/// <param name='username'>The user name to be used for the connection. If null, the credentials of the currently logged-on user are used.</param>
/// <param name='password'>The secure password for the given user name. If the user name is also null, the credentials used will be those of the currently logged-on user.</param>
/// <param name='authority'><para>The authority to be used to authenticate the specified user.</para></param>
/// <param name='impersonation'>The COM impersonation level to be used for the connection.</param>
/// <param name='authentication'>The COM authentication level to be used for the connection.</param>
/// <param name='enablePrivileges'><see langword='true'/>to enable special user privileges; otherwise, <see langword='false'/> . This parameter should only be used when performing an operation that requires special Windows NT user privileges.</param>
/// <param name='context'>A provider-specific, named value pairs object to be passed through to the provider.</param>
/// <param name='timeout'>Reserved for future use.</param>
public ConnectionOptions(string locale,
string username, SecureString password, string authority,
ImpersonationLevel impersonation, AuthenticationLevel authentication,
bool enablePrivileges,
ManagementNamedValueCollection context, TimeSpan timeout) : base(context, timeout)
{
if (locale != null)
this.locale = locale;
this.username = username;
this.enablePrivileges = enablePrivileges;
if (password != null)
{
this.securePassword = password.Copy();
}
if (authority != null)
this.authority = authority;
if (impersonation != 0)
this.impersonation = impersonation;
if (authentication != 0)
this.authentication = authentication;
}
/// <summary>
/// <para> Returns a copy of the object.</para>
/// </summary>
/// <returns>
/// <para>The cloned object.</para>
/// </returns>
public override object Clone()
{
ManagementNamedValueCollection newContext = null;
if (null != Context)
newContext = (ManagementNamedValueCollection)Context.Clone();
return new ConnectionOptions(locale, username, GetSecurePassword(),
authority, impersonation, authentication, enablePrivileges, newContext, Timeout);
}
//
//Methods
//
internal IntPtr GetPassword()
{
if (securePassword != null)
{
try
{
return System.Runtime.InteropServices.Marshal.SecureStringToBSTR(securePassword);
}
catch (OutOfMemoryException)
{
return IntPtr.Zero;
}
}
else
return IntPtr.Zero;
}
internal SecureString GetSecurePassword()
{
if (securePassword != null)
return securePassword.Copy();
else
return null;
}
internal ConnectionOptions(ManagementNamedValueCollection context, TimeSpan timeout, int flags) : base(context, timeout, flags) { }
internal ConnectionOptions(ManagementNamedValueCollection context) : base(context, InfiniteTimeout) { }
internal static ConnectionOptions _Clone(ConnectionOptions options)
{
return ConnectionOptions._Clone(options, null);
}
internal static ConnectionOptions _Clone(ConnectionOptions options, IdentifierChangedEventHandler handler)
{
ConnectionOptions optionsTmp;
if (options != null)
{
optionsTmp = new ConnectionOptions(options.Context, options.Timeout, options.Flags);
optionsTmp.locale = options.locale;
optionsTmp.username = options.username;
optionsTmp.enablePrivileges = options.enablePrivileges;
if (options.securePassword != null)
{
optionsTmp.securePassword = options.securePassword.Copy();
}
else
optionsTmp.securePassword = null;
if (options.authority != null)
optionsTmp.authority = options.authority;
if (options.impersonation != 0)
optionsTmp.impersonation = options.impersonation;
if (options.authentication != 0)
optionsTmp.authentication = options.authentication;
}
else
optionsTmp = new ConnectionOptions();
// Wire up change handler chain. Use supplied handler, if specified;
// otherwise, default to that of the path argument.
if (handler != null)
optionsTmp.IdentifierChanged += handler;
else if (options != null)
optionsTmp.IdentifierChanged += new IdentifierChangedEventHandler(options.HandleIdentifierChange);
return optionsTmp;
}
}//ConnectionOptions
}
| 43.767908 | 267 | 0.567607 | [
"MIT"
] | jtschuster/runtime | src/libraries/System.Management/src/System/Management/ManagementOptions.cs | 76,375 | C# |
using UnityEngine;
namespace GnosticDev
{
public class SimpleUpdateManager : MonoBehaviour
{
public static SimpleUpdateManager instance;
public delegate void OnTick();
/// <summary>
/// Global Tick Event
/// </summary>
public static event OnTick onTick;
public delegate void OnFixedTick();
/// <summary>
/// Global FixedTick Event
/// </summary>
public static event OnFixedTick onFixedTick;
public delegate void OnLateTick();
/// <summary>
/// Global LateTick Event
/// </summary>
public static event OnLateTick onLateTick;
public bool ShouldTick;
private void Awake()
{
if (instance == null)
instance = this;
else if (instance != this)
Destroy(this);
}
private void Update()
{
if (ShouldTick)
{
onTick?.Invoke();
}
}
private void FixedUpdate()
{
if (ShouldTick)
{
onFixedTick?.Invoke();
}
}
private void LateUpdate()
{
if (ShouldTick)
{
onLateTick?.Invoke();
}
}
}
} | 20.859375 | 52 | 0.472659 | [
"MIT"
] | Gnosis-Dev/Simple-Update-Manager | Scripts/SimpleUpdateManager.cs | 1,335 | C# |
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityServer4.Models;
using Microsoft.Extensions.Configuration;
using Volo.Abp.Authorization.Permissions;
using Volo.Abp.Data;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Guids;
using Volo.Abp.IdentityServer.ApiResources;
using Volo.Abp.IdentityServer.ApiScopes;
using Volo.Abp.IdentityServer.Clients;
using Volo.Abp.IdentityServer.IdentityResources;
using Volo.Abp.MultiTenancy;
using Volo.Abp.PermissionManagement;
using Volo.Abp.Uow;
using ApiResource = Volo.Abp.IdentityServer.ApiResources.ApiResource;
using ApiScope = Volo.Abp.IdentityServer.ApiScopes.ApiScope;
using Client = Volo.Abp.IdentityServer.Clients.Client;
namespace Bamboo.Employee.IdentityServer
{
public class IdentityServerDataSeedContributor : IDataSeedContributor, ITransientDependency
{
private readonly IApiResourceRepository _apiResourceRepository;
private readonly IApiScopeRepository _apiScopeRepository;
private readonly IClientRepository _clientRepository;
private readonly IIdentityResourceDataSeeder _identityResourceDataSeeder;
private readonly IGuidGenerator _guidGenerator;
private readonly IPermissionDataSeeder _permissionDataSeeder;
private readonly IConfiguration _configuration;
private readonly ICurrentTenant _currentTenant;
public IdentityServerDataSeedContributor(
IClientRepository clientRepository,
IApiResourceRepository apiResourceRepository,
IApiScopeRepository apiScopeRepository,
IIdentityResourceDataSeeder identityResourceDataSeeder,
IGuidGenerator guidGenerator,
IPermissionDataSeeder permissionDataSeeder,
IConfiguration configuration,
ICurrentTenant currentTenant)
{
_clientRepository = clientRepository;
_apiResourceRepository = apiResourceRepository;
_apiScopeRepository = apiScopeRepository;
_identityResourceDataSeeder = identityResourceDataSeeder;
_guidGenerator = guidGenerator;
_permissionDataSeeder = permissionDataSeeder;
_configuration = configuration;
_currentTenant = currentTenant;
}
[UnitOfWork]
public virtual async Task SeedAsync(DataSeedContext context)
{
using (_currentTenant.Change(context?.TenantId))
{
await _identityResourceDataSeeder.CreateStandardResourcesAsync();
await CreateApiResourcesAsync();
await CreateApiScopesAsync();
await CreateClientsAsync();
}
}
private async Task CreateApiScopesAsync()
{
await CreateApiScopeAsync("Employee");
}
private async Task CreateApiResourcesAsync()
{
var commonApiUserClaims = new[]
{
"email",
"email_verified",
"name",
"phone_number",
"phone_number_verified",
"role"
};
await CreateApiResourceAsync("Employee", commonApiUserClaims);
}
private async Task<ApiResource> CreateApiResourceAsync(string name, IEnumerable<string> claims)
{
var apiResource = await _apiResourceRepository.FindByNameAsync(name);
if (apiResource == null)
{
apiResource = await _apiResourceRepository.InsertAsync(
new ApiResource(
_guidGenerator.Create(),
name,
name + " API"
),
autoSave: true
);
}
foreach (var claim in claims)
{
if (apiResource.FindClaim(claim) == null)
{
apiResource.AddUserClaim(claim);
}
}
return await _apiResourceRepository.UpdateAsync(apiResource);
}
private async Task<ApiScope> CreateApiScopeAsync(string name)
{
var apiScope = await _apiScopeRepository.GetByNameAsync(name);
if (apiScope == null)
{
apiScope = await _apiScopeRepository.InsertAsync(
new ApiScope(
_guidGenerator.Create(),
name,
name + " API"
),
autoSave: true
);
}
return apiScope;
}
private async Task CreateClientsAsync()
{
var commonScopes = new[]
{
"email",
"openid",
"profile",
"role",
"phone",
"address",
"Employee"
};
var configurationSection = _configuration.GetSection("IdentityServer:Clients");
//Web Client
var webClientId = configurationSection["Employee_Web:ClientId"];
if (!webClientId.IsNullOrWhiteSpace())
{
var webClientRootUrl = configurationSection["Employee_Web:RootUrl"].EnsureEndsWith('/');
/* Employee_Web client is only needed if you created a tiered
* solution. Otherwise, you can delete this client. */
await CreateClientAsync(
name: webClientId,
scopes: commonScopes,
grantTypes: new[] { "hybrid" },
secret: (configurationSection["Employee_Web:ClientSecret"] ?? "1q2w3e*").Sha256(),
redirectUri: $"{webClientRootUrl}signin-oidc",
postLogoutRedirectUri: $"{webClientRootUrl}signout-callback-oidc",
frontChannelLogoutUri: $"{webClientRootUrl}Account/FrontChannelLogout",
corsOrigins: new[] { webClientRootUrl.RemovePostFix("/") }
);
}
//Console Test / Angular Client
var consoleAndAngularClientId = configurationSection["Employee_App:ClientId"];
if (!consoleAndAngularClientId.IsNullOrWhiteSpace())
{
var webClientRootUrl = configurationSection["Employee_App:RootUrl"]?.TrimEnd('/');
await CreateClientAsync(
name: consoleAndAngularClientId,
scopes: commonScopes,
grantTypes: new[] { "password", "client_credentials", "authorization_code" },
secret: (configurationSection["Employee_App:ClientSecret"] ?? "1q2w3e*").Sha256(),
requireClientSecret: false,
redirectUri: webClientRootUrl,
postLogoutRedirectUri: webClientRootUrl,
corsOrigins: new[] { webClientRootUrl.RemovePostFix("/") }
);
}
// Blazor Client
var blazorClientId = configurationSection["Employee_Blazor:ClientId"];
if (!blazorClientId.IsNullOrWhiteSpace())
{
var blazorRootUrl = configurationSection["Employee_Blazor:RootUrl"].TrimEnd('/');
await CreateClientAsync(
name: blazorClientId,
scopes: commonScopes,
grantTypes: new[] { "authorization_code" },
secret: configurationSection["Employee_Blazor:ClientSecret"]?.Sha256(),
requireClientSecret: false,
redirectUri: $"{blazorRootUrl}/authentication/login-callback",
postLogoutRedirectUri: $"{blazorRootUrl}/authentication/logout-callback",
corsOrigins: new[] { blazorRootUrl.RemovePostFix("/") }
);
}
// Swagger Client
var swaggerClientId = configurationSection["Employee_Swagger:ClientId"];
if (!swaggerClientId.IsNullOrWhiteSpace())
{
var swaggerRootUrl = configurationSection["Employee_Swagger:RootUrl"].TrimEnd('/');
await CreateClientAsync(
name: swaggerClientId,
scopes: commonScopes,
grantTypes: new[] { "authorization_code" },
secret: configurationSection["Employee_Swagger:ClientSecret"]?.Sha256(),
requireClientSecret: false,
redirectUri: $"{swaggerRootUrl}/swagger/oauth2-redirect.html",
corsOrigins: new[] { swaggerRootUrl.RemovePostFix("/") }
);
}
}
private async Task<Client> CreateClientAsync(
string name,
IEnumerable<string> scopes,
IEnumerable<string> grantTypes,
string secret = null,
string redirectUri = null,
string postLogoutRedirectUri = null,
string frontChannelLogoutUri = null,
bool requireClientSecret = true,
bool requirePkce = false,
IEnumerable<string> permissions = null,
IEnumerable<string> corsOrigins = null)
{
var client = await _clientRepository.FindByClientIdAsync(name);
if (client == null)
{
client = await _clientRepository.InsertAsync(
new Client(
_guidGenerator.Create(),
name
)
{
ClientName = name,
ProtocolType = "oidc",
Description = name,
AlwaysIncludeUserClaimsInIdToken = true,
AllowOfflineAccess = true,
AbsoluteRefreshTokenLifetime = 31536000, //365 days
AccessTokenLifetime = 31536000, //365 days
AuthorizationCodeLifetime = 300,
IdentityTokenLifetime = 300,
RequireConsent = false,
FrontChannelLogoutUri = frontChannelLogoutUri,
RequireClientSecret = requireClientSecret,
RequirePkce = requirePkce
},
autoSave: true
);
}
foreach (var scope in scopes)
{
if (client.FindScope(scope) == null)
{
client.AddScope(scope);
}
}
foreach (var grantType in grantTypes)
{
if (client.FindGrantType(grantType) == null)
{
client.AddGrantType(grantType);
}
}
if (!secret.IsNullOrEmpty())
{
if (client.FindSecret(secret) == null)
{
client.AddSecret(secret);
}
}
if (redirectUri != null)
{
if (client.FindRedirectUri(redirectUri) == null)
{
client.AddRedirectUri(redirectUri);
}
}
if (postLogoutRedirectUri != null)
{
if (client.FindPostLogoutRedirectUri(postLogoutRedirectUri) == null)
{
client.AddPostLogoutRedirectUri(postLogoutRedirectUri);
}
}
if (permissions != null)
{
await _permissionDataSeeder.SeedAsync(
ClientPermissionValueProvider.ProviderName,
name,
permissions,
null
);
}
if (corsOrigins != null)
{
foreach (var origin in corsOrigins)
{
if (!origin.IsNullOrWhiteSpace() && client.FindCorsOrigin(origin) == null)
{
client.AddCorsOrigin(origin);
}
}
}
return await _clientRepository.UpdateAsync(client);
}
}
}
| 37.846154 | 104 | 0.539106 | [
"MIT"
] | BlazorHub/bamboomodules | Bamboo.Employee/host/Bamboo.Employee.IdentityServer/IdentityServer/IdentityServerDataSeedContributor.cs | 12,300 | C# |
/*
This code is derived from jgit (http://eclipse.org/jgit).
Copyright owners are documented in jgit's IP log.
This program and the accompanying materials are made available
under the terms of the Eclipse Distribution License v1.0 which
accompanies this distribution, is reproduced below, and is
available at http://www.eclipse.org/org/documents/edl-v10.php
All rights reserved.
Redistribution and use in source and binary forms, with or
without modification, are permitted provided that the following
conditions are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
- Neither the name of the Eclipse Foundation, Inc. nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using Sharpen;
namespace NGit.Api.Errors
{
/// <summary>
/// Exception thrown when during command execution a low-level exception from the
/// JGit library is thrown.
/// </summary>
/// <remarks>
/// Exception thrown when during command execution a low-level exception from the
/// JGit library is thrown. Also when certain low-level error situations are
/// reported by JGit through return codes this Exception will be thrown.
/// <p>
/// During command execution a lot of exceptions may be thrown. Some of them
/// represent error situations which can be handled specifically by the caller of
/// the command. But a lot of exceptions are so low-level that is is unlikely
/// that the caller of the command can handle them effectively. The huge number
/// of these low-level exceptions which are thrown by the commands lead to a
/// complicated and wide interface of the commands. Callers of the API have to
/// deal with a lot of exceptions they don't understand.
/// <p>
/// To overcome this situation this class was introduced. Commands will wrap all
/// exceptions they declare as low-level in their context into an instance of
/// this class. Callers of the commands have to deal with one type of low-level
/// exceptions. Callers will always get access to the original exception (if
/// available) by calling
/// <code>#getCause()</code>
/// .
/// </remarks>
[System.Serializable]
public class JGitInternalException : RuntimeException
{
private const long serialVersionUID = 1L;
/// <param name="message"></param>
/// <param name="cause"></param>
public JGitInternalException(string message, Exception cause) : base(message, cause
)
{
}
/// <param name="message"></param>
public JGitInternalException(string message) : base(message)
{
}
}
}
| 39.663043 | 85 | 0.763497 | [
"BSD-3-Clause"
] | ashmind/ngit | NGit/NGit.Api.Errors/JGitInternalException.cs | 3,649 | C# |
using System;
using System.Net;
using System.Threading.Tasks;
using Abp.AspNetCore.App.Controllers;
using Abp.AspNetCore.App.Models;
using Abp.Timing;
using Abp.Web.Models;
using Shouldly;
using Xunit;
namespace Abp.AspNetCore.Tests
{
public class DateTimeModelBinder_Tests : AppTestBase
{
[Theory]
[InlineData("2016-04-13T08:58:10.526Z", "utc")]
[InlineData("2016-04-13T08:58:10.526", "local")]
[InlineData("2016-04-13 08:58:10.526Z", "utc")]
[InlineData("2016-04-13 08:58:10.526", "local")]
public async Task Controller_Should_Receive_Correct_DateTimeKind_For_Current_ClockProvider(string date, string expectedKind)
{
Clock.Provider = StringToClockProvider(expectedKind);
var response = await GetResponseAsObjectAsync<AjaxResponse<string>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetDateTimeKind),
new
{
date = date
}
)
);
response.Result.ShouldBe(expectedKind.ToLower());
}
[Theory]
[InlineData("2016-04-13T08:58:10.526Z", "local")]
[InlineData("2016-04-13T08:58:10.526", "unspecified")]
[InlineData("2016-04-13 08:58:10.526Z", "local")]
[InlineData("2016-04-13 08:58:10.526", "unspecified")]
[InlineData("2018-01-18T10:41:52.3257108+03:00", "local")]
public async Task Controller_Should_Receive_Correct_DateTimeKind_For_Current_ClockProvider_When_Not_Normalized_Property(string date, string expectedKind)
{
var response = await GetResponseAsObjectAsync<AjaxResponse<string>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetNotNormalizedDateTimeKindProperty),
new
{
date = WebUtility.UrlEncode(date)
}
)
);
response.Result.ToLower().ShouldBe(expectedKind.ToLower());
}
[Theory]
[InlineData("2016-04-13T08:58:10.526Z", "local")]
[InlineData("2016-04-13T08:58:10.526", "unspecified")]
[InlineData("2016-04-13 08:58:10.526Z", "local")]
[InlineData("2016-04-13 08:58:10.526", "unspecified")]
[InlineData("2018-01-18T10:41:52.3257108+03:00", "local")]
public async Task Controller_Should_Return_Correct_DateTimeKind_For_Not_Normalized_DateTime_Property(string date, string expectedKind)
{
Clock.Provider = ClockProviders.Utc;
var response2 = await GetResponseAsObjectAsync<AjaxResponse<SimpleDateModel2>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetNotNormalizedDateTimeKindProperty2),
new
{
date = WebUtility.UrlEncode(date)
}
)
);
response2.Result.Date.Kind.ShouldBe(StringToClockProvider(expectedKind.ToLower()).Kind);
var response3 = await GetResponseAsObjectAsync<AjaxResponse<SimpleDateModel3>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetNotNormalizedDateTimeKindProperty3),
new
{
date = WebUtility.UrlEncode(date)
}
)
);
response3.Result.Date.Kind.ShouldBe(StringToClockProvider(expectedKind.ToLower()).Kind);
}
[Theory]
[InlineData("2016-04-13T08:58:10.526Z")]
public async Task Controller_Should_Not_Throw_Exception_When_Correct_DateTime_Is_Provided(string date)
{
Clock.Provider = ClockProviders.Utc;
await GetResponseAsObjectAsync<AjaxResponse<SimpleDateModel4>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetNotNormalizedDateTimeKindProperty4),
new
{
date = WebUtility.UrlEncode(date)
}
)
);
}
[Theory]
[InlineData("2016-04-13T08:58:10.526Z", "local")]
[InlineData("2016-04-13T08:58:10.526", "unspecified")]
[InlineData("2016-04-13 08:58:10.526Z", "local")]
[InlineData("2016-04-13 08:58:10.526", "unspecified")]
[InlineData("2018-01-18T10:41:52.3257108+03:00", "local")]
public async Task Controller_Should_Receive_Correct_DateTimeKind_For_Current_ClockProvider_When_Not_Normalized_Class(string date, string expectedKind)
{
var response = await GetResponseAsObjectAsync<AjaxResponse<string>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetNotNormalizedDateTimeKindClass),
new
{
date = WebUtility.UrlEncode(date)
}
)
);
response.Result.ShouldBe(expectedKind.ToLower());
}
[Theory]
[InlineData("2016-04-13T08:58:10.526Z", "utc")]
[InlineData("2016-04-13T08:58:10.526", "local")]
[InlineData("2016-04-13 08:58:10.526Z", "utc")]
[InlineData("2016-04-13 08:58:10.526", "local")]
[InlineData("2016-04-13 08:58:10.526", "unspecified")]
public async Task Controller_Should_Receive_Correct_DateTimeKind_For_Current_ClockProvider_SimpleType(string date, string expectedKind)
{
Clock.Provider = StringToClockProvider(expectedKind);
var response = await GetResponseAsObjectAsync<AjaxResponse<string>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetSimpleTypeDateTimeKind),
new
{
date
}
)
);
response.Result.ShouldBe(expectedKind.ToLower());
}
[Theory]
[InlineData("2016-04-13T08:58:10.526Z", "local")]
[InlineData("2016-04-13T08:58:10.526", "unspecified")]
[InlineData("2016-04-13 08:58:10.526Z", "local")]
[InlineData("2016-04-13 08:58:10.526", "unspecified")]
public async Task Controller_Should_Receive_Correct_DateTimeKind_For_Current_ClockProvider_When_Not_Normalized_Property_SimpleType(string date, string expectedKind)
{
var response = await GetResponseAsObjectAsync<AjaxResponse<string>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetNotNormalizedSimpleTypeKind),
new
{
date
}
)
);
response.Result.ToLower().ShouldBe(expectedKind.ToLower());
}
[Theory]
[InlineData("2016-04-13T08:58:10.526Z", "utc")]
[InlineData("2016-04-13T08:58:10.526", "local")]
[InlineData("2016-04-13 08:58:10.526Z", "utc")]
[InlineData("2016-04-13 08:58:10.526", "local")]
[InlineData("2016-04-13 08:58:10.526", "unspecified")]
public async Task Controller_Should_Receive_Correct_DateTimeKind_For_Current_ClockProvider_NullableSimpleType(string date, string expectedKind)
{
Clock.Provider = StringToClockProvider(expectedKind);
var response = await GetResponseAsObjectAsync<AjaxResponse<string>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetNullableSimpleTypeDateTimeKind),
new
{
date
}
)
);
response.Result.ShouldBe(expectedKind.ToLower());
}
[Theory]
[InlineData("2016-04-13T08:58:10.526Z", "local")]
[InlineData("2016-04-13T08:58:10.526", "unspecified")]
[InlineData("2016-04-13 08:58:10.526Z", "local")]
[InlineData("2016-04-13 08:58:10.526", "unspecified")]
public async Task Controller_Should_Receive_Correct_DateTimeKind_For_Current_ClockProvider_When_Not_Normalized_Property_NullableSimpleType(string date, string expectedKind)
{
var response = await GetResponseAsObjectAsync<AjaxResponse<string>>(
GetUrl<SimpleTestController>(
nameof(SimpleTestController.GetNotNormalizedNullableSimpleTypeDateTimeKind),
new
{
date
}
)
);
response.Result.ToLower().ShouldBe(expectedKind.ToLower());
}
private IClockProvider StringToClockProvider(string dateTimeKind)
{
if (dateTimeKind == "local")
{
return ClockProviders.Local;
}
if (dateTimeKind == "utc")
{
return ClockProviders.Utc;
}
return ClockProviders.Unspecified;
}
}
}
| 39.459227 | 180 | 0.575593 | [
"MIT"
] | AmyliaScarlet/aspnetboilerplate | test/Abp.AspNetCore.Tests/Tests/DateTimeModelBinder_Tests.cs | 9,196 | C# |
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.Models
{
public class TemplateSynonym
{
[Required]
public int Id { get; set; }
[Required]
public string Key { get; set; }
[Required]
public string Value { get; set; }
[Required]
public string Description { get; set; }
[Required]
public int ClientId { get; set; }
}
}
| 19.535714 | 47 | 0.619744 | [
"Apache-2.0"
] | alex-coupe/MarketingTool | source/MarketingTool/DataAccess/Models/TemplateSynonym.cs | 549 | C# |
using System;
namespace Sh8ps.Services
{
public class SuspensionState
{
public object Data { get; set; }
public DateTime SuspensionDate { get; set; }
}
}
| 15.416667 | 52 | 0.621622 | [
"MIT"
] | nohorse/sh8ps | Sh8ps/Sh8ps/Services/SuspensionState.cs | 187 | C# |
using System;
using System.Runtime.InteropServices;
namespace hds
{
public class AttributeClass2018 :GameObject
{
public Attribute Orientation = new Attribute(16, "Orientation");
public Attribute Position = new Attribute(24, "Position");
public Attribute HalfExtents = new Attribute(12, "HalfExtents");
public AttributeClass2018(string name,UInt16 _goid)
: base(3, 0, name, _goid, 0xFFFFFFFF)
{
AddAttribute(ref Orientation, 0, -1);
AddAttribute(ref Position, 1, -1);
AddAttribute(ref HalfExtents, 2, -1);
}
}
} | 24.166667 | 68 | 0.677586 | [
"MIT"
] | hdneo/mxo-hd | hds/resources/gameobjects/definitions/AttributeClasses/AttributeClass2018.cs | 580 | C# |
using System;
using System.Text;
using System.Collections.Generic;
namespace Vokabular.ForumSite.DataEntities.Database.Entities {
public class NntpTopic {
public int NntpTopicID { get; set; }
public NntpForum NntpForum { get; set; }
public Topic Topic { get; set; }
public string Thread { get; set; }
}
}
| 23.466667 | 62 | 0.659091 | [
"BSD-3-Clause"
] | RIDICS/ITJakub | UJCSystem/Vokabular.Forum.DataEntities/Database/Entities/Nntptopic.cs | 352 | C# |
/*
Copyright (c) 2019-2020 VMware, Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
using Harmony;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace VMware.Shims
{
public class EventLogShim : ShimsBase<EventLogShim>
{
[HarmonyPatch]
private static class EventLogInternal_WriteEntry
{
private static MethodBase TargetMethod()
{
return AccessTools
.TypeByName("System.Diagnostics.EventLogInternal")
.GetMethod("WriteEntry", new[] { typeof(string), typeof(EventLogEntryType), typeof(int), typeof(short), typeof(byte[]) });
}
private static bool Prefix(object __instance, string message, EventLogEntryType type)
{
Instance.InvocationCheck++;
var source = Traverse.Create(__instance).Field("sourceName").GetValue<string>();
var entry = $"{source}: {message}";
if (type == EventLogEntryType.Error)
Console.Error.WriteLine(entry);
else
Console.WriteLine(entry);
return false;
}
}
[HarmonyPatch]
private static class EventLogInternal_WriteEvent
{
private static MethodBase TargetMethod()
{
return AccessTools
.TypeByName("System.Diagnostics.EventLogInternal")
.GetMethod("WriteEvent", new[] { typeof(EventInstance), typeof(byte[]), typeof(object[]) });
}
private static bool Prefix(object __instance, EventInstance instance, object[] values)
{
Instance.InvocationCheck++;
if (values == null)
return false;
var message = values.Select(x => x.ToString() + "\n");
var source = Traverse.Create(__instance).Field("sourceName").GetValue<string>();
var entry = $"{source}: {message}";
if (instance.EntryType == EventLogEntryType.Error)
Console.Error.WriteLine(entry);
else
Console.WriteLine(entry);
return false;
}
}
[HarmonyPatch]
private static class EventLog_SourceExists
{
private static MethodBase TargetMethod()
{
return AccessTools
.TypeByName("System.Diagnostics.EventLog")
.GetMethod("SourceExists", new[] { typeof(string), typeof(string) });
}
private static bool Prefix(object __instance, ref bool __result) //, bool wantToCreate)
{
__result = true;
return false;
}
}
//[HarmonyPatch]
//private static class EventLog_CreateEventSource
//{
// private static MethodBase TargetMethod()
// {
// return AccessTools
// .TypeByName("System.Diagnostics.EventLog")
// .GetMethod("CreateEventSource", new[] { typeof(System.Diagnostics.EventSourceCreationData) });
// }
// private static bool Prefix() //, bool wantToCreate)
// {
// Instance.InvocationCheck++;
// return false;
// }
//}
}
}
| 38.168 | 142 | 0.607839 | [
"BSD-2-Clause"
] | vmware/eventlog-stream-console | src/VMware.Shims/EventLogShim.cs | 4,773 | C# |
using Abp.Application.Services.Dto;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WikiTutorial.ProductServices.Dtos
{
public class GetAllProductsItem : EntityDto<long>
{
public string Name { get; set; }
public string Description { get; set; }
public float Value { get; set; }
}
}
| 23.411765 | 53 | 0.703518 | [
"MIT"
] | diguifi/WikiTutorial | src/WikiTutorial.Application/ProductServices/Dtos/GetAllProductsItem.cs | 400 | C# |
namespace Tests
{
using System.Linq;
using System.Molecular;
using NUnit.Framework;
public class TranscribeTest
{
[Test]
public void FirstTest()
{
var code = "TAACCCTAACCCTAACCCTAACCCTAACCCTAACCCTAACCCTAACCCTAACCCTAACCCTAACCCTAACCC";
var dna = RNA.Transcribe(code);
Assert.AreEqual(code.Length / 3, dna.Codons.Length);
Assert.True(dna.Codons.First().IsStop());
}
}
} | 27.111111 | 99 | 0.590164 | [
"MIT"
] | 0xF6/Genome | test/System.Molecular.Test/TranscribeTest.cs | 488 | C# |
namespace UnityTest
{
public class RenderingOptions
{
public string nameFilter;
public bool showSucceeded;
public bool showFailed;
public bool showIgnored;
public bool showNotRunned;
public string[] categories;
}
}
| 17.692308 | 30 | 0.765217 | [
"MIT"
] | Energy0124/unity3d-plugin | src/test/resources/org/jenkinsci/plugins/unity3d/IntegrationTests/testExpectADifferentExitCode/jobs/test_unity3d/workspace/Assets/UnityTestTools/UnitTesting/Editor/NUnit/Renderer/RenderingOptions.cs | 230 | C# |
using PKISharp.WACS.Clients;
using PKISharp.WACS.Extensions;
using PKISharp.WACS.Plugins.Base;
using PKISharp.WACS.Plugins.Interfaces;
using PKISharp.WACS.Services;
using Microsoft.Web.Administration;
using System;
using System.Collections.Generic;
using System.Linq;
namespace PKISharp.WACS.Plugins.TargetPlugins
{
internal class IISSiteFactory : BaseTargetPluginFactory<IISSite>
{
public override bool Hidden => _iisClient.Version.Major == 0;
protected IISClient _iisClient;
public IISSiteFactory(ILogService log, IISClient iisClient) :
base(log, nameof(IISSite), "SAN certificate for all bindings of an IIS site")
{
_iisClient = iisClient;
}
}
internal class IISSite : ITargetPlugin
{
protected ILogService _log;
protected IISClient _iisClient;
public IISSite(ILogService logService, IISClient iisClient)
{
_log = logService;
_iisClient = iisClient;
}
Target ITargetPlugin.Default(IOptionsService optionsService)
{
var rawSiteId = optionsService.TryGetRequiredOption(nameof(optionsService.Options.SiteId), optionsService.Options.SiteId);
long siteId = 0;
if (long.TryParse(rawSiteId, out siteId))
{
var found = GetSites(false, false).FirstOrDefault(binding => binding.TargetSiteId == siteId);
if (found != null)
{
found.ExcludeBindings = optionsService.Options.ExcludeBindings;
found.CommonName = optionsService.Options.CommonName;
if (!found.IsCommonNameValid(_log)) return null;
return found;
}
else
{
_log.Error("Unable to find SiteId {siteId}", siteId);
}
}
else
{
_log.Error("Invalid SiteId {siteId}", optionsService.Options.SiteId);
}
return null;
}
Target ITargetPlugin.Aquire(IOptionsService optionsService, IInputService inputService, RunLevel runLevel)
{
var chosen = inputService.ChooseFromList("Choose site",
GetSites(optionsService.Options.HideHttps, true).Where(x => x.Hidden == false),
x => new Choice<Target>(x) { Description = x.Host },
true);
if (chosen != null)
{
// Exclude bindings
inputService.WritePagedList(chosen.AlternativeNames.Select(x => Choice.Create(x, "")));
chosen.ExcludeBindings = inputService.RequestString("Press enter to include all listed hosts, or type a comma-separated lists of exclusions");
if (runLevel >= RunLevel.Advanced) chosen.AskForCommonNameChoice(inputService);
return chosen;
}
return null;
}
Target ITargetPlugin.Refresh(Target scheduled)
{
var match = GetSites(false, false).FirstOrDefault(binding => binding.TargetSiteId == scheduled.TargetSiteId);
if (match != null)
{
_iisClient.UpdateAlternativeNames(scheduled, match);
return scheduled;
}
_log.Error("SiteId {id} not found", scheduled.TargetSiteId);
return null;
}
internal List<Target> GetSites(bool hideHttps, bool logInvalidSites)
{
if (_iisClient.ServerManager == null) {
_log.Warning("IIS not found. Skipping scan.");
return new List<Target>();
}
// Get all bindings matched together with their respective sites
_log.Debug("Scanning IIS sites");
var sites = _iisClient.WebSites;
// Option: hide http bindings when there are already https equivalents
var hidden = sites.Take(0);
if (hideHttps)
{
hidden = sites.Where(site => site.Bindings.
All(binding => binding.Protocol == "https" ||
site.Bindings.Any(other => other.Protocol == "https" &&
string.Equals(other.Host, binding.Host, StringComparison.InvariantCultureIgnoreCase))));
}
var targets = sites.
Select(site => new Target {
TargetSiteId = site.Id,
Host = site.Name,
HostIsDns = false,
Hidden = hidden.Contains(site),
WebRootPath = site.WebRoot(),
IIS = true,
AlternativeNames = GetHosts(site)
}).
Where(target => {
if (target.AlternativeNames.Count > Constants.maxNames) {
if (target.Hidden == false && logInvalidSites) {
_log.Information("{site} has too many hosts for a single certificate. ACME has a maximum of {maxNames}.", target.Host, Constants.maxNames);
}
return false;
} else if (target.AlternativeNames.Count == 0) {
if (target.Hidden == false && logInvalidSites) {
_log.Information("No valid hosts found for {site}.", target.Host);
}
return false;
}
return true;
}).
OrderBy(target => target.Host).
ToList();
if (!targets.Any() && logInvalidSites) {
_log.Warning("No applicable IIS sites were found.");
}
return targets;
}
private List<string> GetHosts(Site site) {
return site.Bindings.Select(x => x.Host.ToLower()).
Where(x => !string.IsNullOrWhiteSpace(x)).
Where(x => !x.StartsWith("*")).
Select(x => _iisClient.IdnMapping.GetAscii(x)).
Distinct().
ToList();
}
public virtual IEnumerable<Target> Split(Target scheduled)
{
return new List<Target> { scheduled };
}
}
} | 41.13125 | 168 | 0.517551 | [
"Apache-2.0"
] | helixge/win-acme | letsencrypt-win-simple/Plugins/TargetPlugins/IISSite.cs | 6,583 | C# |
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Scantegra.Core.Entities
{
[System.Runtime.Serialization.DataContractAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("CrmSvcUtil", "9.0.0.9154")]
public enum Metric_StatusCode
{
[System.Runtime.Serialization.EnumMemberAttribute()]
Closed = 1,
[System.Runtime.Serialization.EnumMemberAttribute()]
Open = 0,
}
} | 29.96 | 80 | 0.563418 | [
"MIT"
] | scantegra/scantegra | src/Scantegra.Core/Entities/OptionSets/Metric_StatusCode.cs | 749 | C# |
using BrawlLib.Imaging;
using BrawlLib.Internal;
using BrawlLib.SSBB.Types;
using System.ComponentModel;
namespace BrawlLib.SSBB.ResourceNodes
{
public unsafe class REFFParticleNode : ResourceNode
{
internal ParticleParameterHeader* Params => (ParticleParameterHeader*) WorkingUncompressed.Address;
public override ResourceType ResourceFileType => ResourceType.Unknown;
private ParticleParameterHeader hdr;
private ParticleParameterDesc desc;
//[Category("Particle Parameters")]
//public uint HeaderSize { get { return hdr.headersize; } }
[Category("Particle Parameters")]
[TypeConverter(typeof(RGBAStringConverter))]
public RGBAPixel Color1Primary
{
get => desc.mColor11;
set
{
desc.mColor11 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(RGBAStringConverter))]
public RGBAPixel Color1Secondary
{
get => desc.mColor12;
set
{
desc.mColor12 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(RGBAStringConverter))]
public RGBAPixel Color2Primary
{
get => desc.mColor21;
set
{
desc.mColor21 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(RGBAStringConverter))]
public RGBAPixel Color2Secondary
{
get => desc.mColor22;
set
{
desc.mColor22 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector2StringConverter))]
public Vector2 Size
{
get => desc.size;
set
{
desc.size = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector2StringConverter))]
public Vector2 Scale
{
get => desc.scale;
set
{
desc.scale = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector3StringConverter))]
public Vector3 Rotate
{
get => desc.rotate;
set
{
desc.rotate = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector2StringConverter))]
public Vector2 TextureScale1
{
get => desc.textureScale1;
set
{
desc.textureScale1 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector2StringConverter))]
public Vector2 TextureScale2
{
get => desc.textureScale2;
set
{
desc.textureScale2 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector2StringConverter))]
public Vector2 TextureScale3
{
get => desc.textureScale3;
set
{
desc.textureScale3 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector3StringConverter))]
public Vector3 TextureRotate
{
get => desc.textureRotate;
set
{
desc.textureRotate = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector2StringConverter))]
public Vector2 TextureTranslate1
{
get => desc.textureTranslate1;
set
{
desc.textureTranslate1 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector2StringConverter))]
public Vector2 TextureTranslate2
{
get => desc.textureTranslate2;
set
{
desc.textureTranslate2 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector2StringConverter))]
public Vector2 TextureTranslate3
{
get => desc.textureTranslate3;
set
{
desc.textureTranslate3 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public ushort TextureWrap
{
get => desc.textureWrap;
set
{
desc.textureWrap = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public byte TextureReverse
{
get => desc.textureReverse;
set
{
desc.textureReverse = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public byte AlphaCompareRef0
{
get => desc.mACmpRef0;
set
{
desc.mACmpRef0 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public byte AlphaCompareRef1
{
get => desc.mACmpRef1;
set
{
desc.mACmpRef1 = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public byte RotateOffsetRandom1
{
get => desc.rotateOffsetRandomX;
set
{
desc.rotateOffsetRandomX = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public byte RotateOffsetRandom2
{
get => desc.rotateOffsetRandomY;
set
{
desc.rotateOffsetRandomY = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public byte RotateOffsetRandom3
{
get => desc.rotateOffsetRandomZ;
set
{
desc.rotateOffsetRandomZ = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
[TypeConverter(typeof(Vector3StringConverter))]
public Vector3 RotateOffset
{
get => desc.rotateOffset;
set
{
desc.rotateOffset = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public string Texture1Name
{
get => _textureNames[0];
set
{
_textureNames[0] = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public string Texture2Name
{
get => _textureNames[1];
set
{
_textureNames[1] = value;
SignalPropertyChange();
}
}
[Category("Particle Parameters")]
public string Texture3Name
{
get => _textureNames[2];
set
{
_textureNames[2] = value;
SignalPropertyChange();
}
}
public string[] _textureNames = new string[3] {"", "", ""};
public override bool OnInitialize()
{
_name = "Particle";
hdr = *Params;
desc = hdr.paramDesc;
VoidPtr addr = Params->paramDesc.textureNames.Address;
for (int i = 0; i < 3; i++)
{
if (*(bushort*) addr > 1)
{
_textureNames[i] = new string((sbyte*) (addr + 2));
}
else
{
_textureNames[i] = null;
}
addr += 2 + *(bushort*) addr;
}
return false;
}
public override int OnCalculateSize(bool force)
{
int size = 0x8C;
foreach (string s in _textureNames)
{
size += 3;
if (s != null && s.Length > 0)
{
size += s.Length;
}
}
return size.Align(4);
}
public override void OnRebuild(VoidPtr address, int length, bool force)
{
ParticleParameterHeader* p = (ParticleParameterHeader*) address;
p->headersize = (uint) length - 4;
p->paramDesc = desc;
sbyte* ptr = (sbyte*) p->paramDesc.textureNames.Address;
foreach (string s in _textureNames)
{
if (s != null && s.Length > 0)
{
*(bushort*) ptr = (ushort) (s.Length + 1);
ptr += 2;
s.Write(ref ptr);
}
else
{
*(bushort*) ptr = 1;
ptr += 3;
}
}
}
}
} | 26.465054 | 107 | 0.465515 | [
"MIT"
] | GamendeMier/BrawlCrate | BrawlLib/SSBB/ResourceNodes/Graphics/REFF/REFFParticleNode.cs | 9,847 | C# |
// *** WARNING: this file was generated by the Pulumi SDK Generator. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Pulumi.Serialization;
namespace Pulumi.AzureNextGen.RecoveryServices.Latest.Outputs
{
[OutputType]
public sealed class InMageAzureV2PolicyDetailsResponse
{
/// <summary>
/// The app consistent snapshot frequency in minutes.
/// </summary>
public readonly int? AppConsistentFrequencyInMinutes;
/// <summary>
/// The crash consistent snapshot frequency in minutes.
/// </summary>
public readonly int? CrashConsistentFrequencyInMinutes;
/// <summary>
/// Gets the class type. Overridden in derived classes.
/// Expected value is 'InMageAzureV2'.
/// </summary>
public readonly string InstanceType;
/// <summary>
/// A value indicating whether multi-VM sync has to be enabled.
/// </summary>
public readonly string? MultiVmSyncStatus;
/// <summary>
/// The duration in minutes until which the recovery points need to be stored.
/// </summary>
public readonly int? RecoveryPointHistory;
/// <summary>
/// The recovery point threshold in minutes.
/// </summary>
public readonly int? RecoveryPointThresholdInMinutes;
[OutputConstructor]
private InMageAzureV2PolicyDetailsResponse(
int? appConsistentFrequencyInMinutes,
int? crashConsistentFrequencyInMinutes,
string instanceType,
string? multiVmSyncStatus,
int? recoveryPointHistory,
int? recoveryPointThresholdInMinutes)
{
AppConsistentFrequencyInMinutes = appConsistentFrequencyInMinutes;
CrashConsistentFrequencyInMinutes = crashConsistentFrequencyInMinutes;
InstanceType = instanceType;
MultiVmSyncStatus = multiVmSyncStatus;
RecoveryPointHistory = recoveryPointHistory;
RecoveryPointThresholdInMinutes = recoveryPointThresholdInMinutes;
}
}
}
| 34.876923 | 86 | 0.657697 | [
"Apache-2.0"
] | pulumi/pulumi-azure-nextgen | sdk/dotnet/RecoveryServices/Latest/Outputs/InMageAzureV2PolicyDetailsResponse.cs | 2,267 | C# |
using MySql.Data.MySqlClient;
using Projeto_Integrador_1.Util;
using System;
using System.Collections.Generic;
namespace Projeto_Integrador_1.Connection {
class Viagens : Config {
public Viagens() { }
public bool Success;
public string Message;
public List<dynamic> Results = new List<dynamic>();
public int Id { get; set; }
public dynamic Remetente { get; set; }
public dynamic Destinatario { get; set; }
public dynamic Tomador { get; set; }
public string CodigoInterno { get; set; }
public dynamic TipoViagem { get; set; }
public dynamic Veiculo { get; set; }
public dynamic Reboque { get; set; }
public dynamic Motorista { get; set; }
public string SaidaCidade { get; set; }
public dynamic SaidaUF { get; set; }
public string DestinoCidade { get; set; }
public dynamic DestinoUF { get; set; }
public dynamic Status { get; set; }
public string DataSaida { get; set; }
public string DataEntrega { get; set; }
public string DataChegada { get; set; }
public string HodometroSaida { get; set; }
public string HodometroEntrega { get; set; }
public string HodometroChegada { get; set; }
public string HodometroPercorrido { get; set; }
public string Valor { get; set; }
public string InformacoesComplementares { get; set; }
public string Cargas { get; set; }
public string TotalCargas { get; set; }
public string Custos { get; set; }
public string TotalCustos { get; set; }
public string Abastecimentos { get; set; }
public string TotalAbastecimentos { get; set; }
public void Create() {
string sql = "INSERT INTO `viagens` (`remetente`, `destinatario`, `tomador`, `codigo_interno`, `tipo_viagem`, `veiculo`, `reboque`, `motorista`, `saida_cidade`, `saida_uf`, `destino_cidade`, `destino_uf`, `status`, `data_saida`, `data_entrega`, `data_chegada`, `hodometro_saida`, `hodometro_entrega`, `hodometro_chegada`, `hodometro_percorrido`, `valor`, `informacoes_complementares`, `cargas`, `valor_cargas`, `custos`, `valor_custos`, `abastecimentos`, `valor_abastecimentos`) VALUES (@remetente, @destinatario, @tomador, @codigo_interno, @tipo_viagem, @veiculo, @reboque, @motorista, @saida_cidade, @saida_uf, @destino_cidade, @destino_uf, @status, @data_saida, @data_entrega, @data_chegada, @hodometro_saida, @hodometro_entrega, @hodometro_chegada, @hodometro_percorrido, @valor, @informacoes_complementares, @cargas, @valor_cargas, @custos, @valor_custos, @abastecimentos, @valor_abastecimentos);";
try {
OpenConnection();
MySqlCommand query = new MySqlCommand(sql, Connection);
query.Parameters.AddWithValue("@remetente", Remetente);
query.Parameters.AddWithValue("@destinatario", Destinatario);
query.Parameters.AddWithValue("@tomador", Tomador);
query.Parameters.AddWithValue("@codigo_interno", CodigoInterno);
query.Parameters.AddWithValue("@tipo_viagem", TipoViagem);
query.Parameters.AddWithValue("@veiculo", Veiculo);
query.Parameters.AddWithValue("@reboque", Converter.ToIntDB(Reboque, true));
query.Parameters.AddWithValue("@motorista", Motorista);
query.Parameters.AddWithValue("@saida_cidade", SaidaCidade);
query.Parameters.AddWithValue("@saida_uf", SaidaUF);
query.Parameters.AddWithValue("@destino_cidade", DestinoCidade);
query.Parameters.AddWithValue("@destino_uf", DestinoUF);
query.Parameters.AddWithValue("@status", Status);
query.Parameters.AddWithValue("@data_saida", DateTime.Parse(DataSaida));
query.Parameters.AddWithValue("@data_entrega", (!string.IsNullOrWhiteSpace(DataEntrega) ? (object)DateTime.Parse(DataEntrega) : DBNull.Value));
query.Parameters.AddWithValue("@data_chegada", (!string.IsNullOrWhiteSpace(DataChegada) ? (object)DateTime.Parse(DataChegada) : DBNull.Value));
query.Parameters.AddWithValue("@hodometro_saida", Converter.ToIntDB(HodometroSaida, true));
query.Parameters.AddWithValue("@hodometro_entrega", Converter.ToIntDB(HodometroEntrega, true));
query.Parameters.AddWithValue("@hodometro_chegada", Converter.ToIntDB(HodometroChegada, true));
query.Parameters.AddWithValue("@hodometro_percorrido", Converter.ToIntDB(HodometroPercorrido, true));
query.Parameters.AddWithValue("@valor", Valor);
query.Parameters.AddWithValue("@informacoes_complementares", InformacoesComplementares);
query.Parameters.AddWithValue("@cargas", Cargas);
query.Parameters.AddWithValue("@valor_cargas", TotalCargas);
query.Parameters.AddWithValue("@custos", Custos);
query.Parameters.AddWithValue("@valor_custos", TotalCustos);
query.Parameters.AddWithValue("@abastecimentos", Abastecimentos);
query.Parameters.AddWithValue("@valor_abastecimentos", TotalAbastecimentos);
query.ExecuteNonQuery();
CloseConnection();
Success = true;
Message = "Viagem salva com sucesso.";
}
catch (Exception e) {
Success = false;
Message = e.Message;
}
}
public void Update() {
string sql = "UPDATE `viagens` SET `remetente` = @remetente, `destinatario` = @destinatario, `tomador` = @tomador, `codigo_interno` = @codigo_interno, `tipo_viagem` = @tipo_viagem, `veiculo` = @veiculo, `reboque` = @reboque, `motorista` = @motorista, `saida_cidade` = @saida_cidade, `saida_uf` = @saida_uf, `destino_cidade` = @destino_cidade, `destino_uf` = @destino_uf, `status` = @status, `data_saida` = @data_saida, `data_entrega` = @data_entrega, `data_chegada` = @data_chegada, `hodometro_saida` = @hodometro_saida, `hodometro_entrega` = @hodometro_entrega, `hodometro_chegada` = @hodometro_chegada, `hodometro_percorrido` = @hodometro_percorrido, `valor` = @valor, `informacoes_complementares` = @informacoes_complementares, `cargas` = @cargas, `valor_cargas` = @valor_cargas, `custos` = @custos, `valor_custos` = @valor_custos, `abastecimentos` = @abastecimentos, `valor_abastecimentos` = @valor_abastecimentos WHERE `id` = @id LIMIT 1;";
try {
OpenConnection();
MySqlCommand query = new MySqlCommand(sql, Connection);
query.Parameters.AddWithValue("@remetente", Remetente);
query.Parameters.AddWithValue("@destinatario", Destinatario);
query.Parameters.AddWithValue("@tomador", Tomador);
query.Parameters.AddWithValue("@codigo_interno", CodigoInterno);
query.Parameters.AddWithValue("@tipo_viagem", TipoViagem);
query.Parameters.AddWithValue("@veiculo", Veiculo);
query.Parameters.AddWithValue("@reboque", Converter.ToIntDB(Reboque, true));
query.Parameters.AddWithValue("@motorista", Motorista);
query.Parameters.AddWithValue("@saida_cidade", SaidaCidade);
query.Parameters.AddWithValue("@saida_uf", SaidaUF);
query.Parameters.AddWithValue("@destino_cidade", DestinoCidade);
query.Parameters.AddWithValue("@destino_uf", DestinoUF);
query.Parameters.AddWithValue("@status", Status);
query.Parameters.AddWithValue("@data_saida", DateTime.Parse(DataSaida));
query.Parameters.AddWithValue("@data_entrega", (!string.IsNullOrWhiteSpace(DataEntrega) ? (object)DateTime.Parse(DataEntrega) : DBNull.Value));
query.Parameters.AddWithValue("@data_chegada", (!string.IsNullOrWhiteSpace(DataChegada) ? (object)DateTime.Parse(DataChegada) : DBNull.Value));
query.Parameters.AddWithValue("@hodometro_saida", Converter.ToIntDB(HodometroSaida, true));
query.Parameters.AddWithValue("@hodometro_entrega", Converter.ToIntDB(HodometroEntrega, true));
query.Parameters.AddWithValue("@hodometro_chegada", Converter.ToIntDB(HodometroChegada, true));
query.Parameters.AddWithValue("@hodometro_percorrido", Converter.ToIntDB(HodometroPercorrido, true));
query.Parameters.AddWithValue("@valor", Valor);
query.Parameters.AddWithValue("@informacoes_complementares", InformacoesComplementares);
query.Parameters.AddWithValue("@cargas", Cargas);
query.Parameters.AddWithValue("@valor_cargas", TotalCargas);
query.Parameters.AddWithValue("@custos", Custos);
query.Parameters.AddWithValue("@valor_custos", TotalCustos);
query.Parameters.AddWithValue("@abastecimentos", Abastecimentos);
query.Parameters.AddWithValue("@valor_abastecimentos", TotalAbastecimentos);
query.Parameters.AddWithValue("@id", Id);
query.ExecuteNonQuery();
CloseConnection();
Success = true;
Message = "Viagem salva com sucesso.";
}
catch (Exception e) {
Success = false;
Message = e.Message;
}
}
public void Get() {
string sql = "SELECT `viagens`.*, `veiculos`.`placa` AS `veiculo_placa`, `motoristas`.`nome` AS `motorista_nome` FROM `viagens` LEFT OUTER JOIN `veiculos` ON (`viagens`.`veiculo` = `veiculos`.`id`) LEFT OUTER JOIN `motoristas` ON (`viagens`.`motorista` = `motoristas`.`id`) WHERE `viagens`.`id` = @id LIMIT 1;";
try {
OpenConnection();
MySqlCommand query = new MySqlCommand(sql, Connection);
query.Parameters.AddWithValue("@id", Id);
MySqlDataReader data = query.ExecuteReader();
data.Read();
Results.Add(new {
Id = data["id"],
Remetente = data["remetente"],
Destinatario = data["destinatario"],
Tomador = data["tomador"],
CodigoInterno = data["codigo_interno"],
TipoViagem = data["tipo_viagem"],
Veiculo = data["veiculo"],
Reboque = data["reboque"],
Motorista = data["motorista"],
SaidaCidade = data["saida_cidade"],
SaidaUF = data["saida_uf"],
DestinoCidade = data["destino_cidade"],
DestinoUF = data["destino_uf"],
Status = data["status"],
DataSaida = Converter.DateToString(data["data_saida"], "dd/MM/yyyy HH:mm"),
DataEntrega = Converter.DateToString(data["data_entrega"], "dd/MM/yyyy HH:mm"),
DataChegada = Converter.DateToString(data["data_chegada"], "dd/MM/yyyy HH:mm"),
HodometroSaida = data["hodometro_saida"],
HodometroEntrega = data["hodometro_entrega"],
HodometroChegada = data["hodometro_chegada"],
HodometroPercorrido = data["hodometro_percorrido"],
Valor = data["valor"],
InformacoesComplementares = data["informacoes_complementares"],
Cargas = data["cargas"],
Custos = data["custos"],
Abastecimentos = data["abastecimentos"]
});
data.Close();
CloseConnection();
Success = true;
}
catch (Exception e) {
Success = false;
Message = e.Message;
}
}
public void GetAll() {
string sql = "SELECT `viagens`.*, `veiculos`.`placa` AS `veiculo_placa`, `motoristas`.`nome` AS `motorista_nome` FROM `viagens` LEFT OUTER JOIN `veiculos` ON (`viagens`.`veiculo` = `veiculos`.`id`) LEFT OUTER JOIN `motoristas` ON (`viagens`.`motorista` = `motoristas`.`id`);";
try {
OpenConnection();
MySqlCommand query = new MySqlCommand(sql, Connection);
MySqlDataReader data = query.ExecuteReader();
while (data.Read()) {
Results.Add(new {
Id = data["id"],
CodigoInterno = data["codigo_interno"],
DataSaida = data["data_saida"],
DataChegada = data["data_chegada"],
SaidaCidade = data["saida_cidade"],
SaidaUF = data["saida_uf"],
DestinoCidade = data["destino_cidade"],
DestinoUF = data["destino_uf"],
Placa = data["veiculo_placa"],
Motorista = data["motorista_nome"],
Valor = data["valor"],
Status = data["status"],
TotalCargas = data["valor_cargas"],
TotalCustos = data["valor_custos"],
TotalAbastecimentos = data["valor_abastecimentos"]
});
}
data.Close();
CloseConnection();
Success = true;
}
catch (Exception e) {
Success = false;
Message = e.Message;
}
}
public void Delete() {
string sql = "DELETE FROM `viagens` WHERE `id` = @id LIMIT 1;";
try {
OpenConnection();
MySqlCommand query = new MySqlCommand(sql, Connection);
query.Parameters.AddWithValue("@id", Id);
query.ExecuteNonQuery();
CloseConnection();
Success = true;
Message = "Viagem excluida com sucesso.";
}
catch (Exception e) {
Success = false;
Message = e.Message;
}
}
}
}
| 55.562016 | 957 | 0.588699 | [
"MIT"
] | igorscheffer/Projeto-Integrador-1 | Projeto Integrador 1/Projeto Integrador 1/Connection/Viagens.cs | 14,337 | C# |
using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:2.0.50727.3074
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
[assembly: CLSCompliantAttribute(false)]
[assembly: ComVisibleAttribute(false)]
[assembly: AssemblyTitleAttribute("Cuyahoga.Web for Microsoft .NET Framework 2.0")]
[assembly: AssemblyDescriptionAttribute("")]
[assembly: AssemblyCompanyAttribute("Cuyahoga Project")]
[assembly: AssemblyProductAttribute("Cuyahoga")]
[assembly: AssemblyCopyrightAttribute("2004-2008 Cuyahoga Project. All rights reserved.")]
[assembly: AssemblyVersionAttribute("1.6.0.0")]
[assembly: AssemblyInformationalVersionAttribute("1.6.0.809")]
[assembly: AssemblyFileVersionAttribute("1.6.0.0")]
[assembly: AllowPartiallyTrustedCallersAttribute()]
| 40.896552 | 91 | 0.653457 | [
"BSD-3-Clause"
] | dineshkummarc/cuyahoga-1 | Web/Properties/AssemblyInfo.cs | 1,186 | C# |
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="RibbonBackstageTabItemHeader.cs" company="WildGums">
// Copyright (c) 2008 - 2014 WildGums. All rights reserved.
// </copyright>
// --------------------------------------------------------------------------------------------------------------------
namespace Orchestra.Controls
{
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
public class RibbonBackstageTabItemHeader : ContentControl
{
public RibbonBackstageTabItemHeader()
{
}
public bool KeepIconSizeWithoutIcon
{
get { return (bool)GetValue(KeepIconSizeWithoutIconProperty); }
set { SetValue(KeepIconSizeWithoutIconProperty, value); }
}
// Using a DependencyProperty as the backing store for KeepIconSizeWithoutIcon. This enables animation, styling, binding, etc...
public static readonly DependencyProperty KeepIconSizeWithoutIconProperty = DependencyProperty.Register("KeepIconSizeWithoutIcon", typeof(bool), typeof(RibbonBackstageTabItemHeader), new PropertyMetadata(false, (sender, e) => ((RibbonBackstageTabItemHeader)sender).BuildHeader()));
public ImageSource Icon
{
get { return (ImageSource)GetValue(IconProperty); }
set { SetValue(IconProperty, value); }
}
public static readonly DependencyProperty IconProperty = DependencyProperty.Register("Icon", typeof(ImageSource),
typeof(RibbonBackstageTabItemHeader), new PropertyMetadata(null, (sender, e) => ((RibbonBackstageTabItemHeader)sender).BuildHeader()));
public string HeaderText
{
get { return (string)GetValue(HeaderTextProperty); }
set { SetValue(HeaderTextProperty, value); }
}
// Using a DependencyProperty as the backing store for HeaderText. This enables animation, styling, binding, etc...
public static readonly DependencyProperty HeaderTextProperty = DependencyProperty.Register("HeaderText", typeof(string),
typeof(RibbonBackstageTabItemHeader), new PropertyMetadata(string.Empty, (sender, e) => ((RibbonBackstageTabItemHeader)sender).BuildHeader()));
public string HeaderTextStyleKey
{
get { return (string)GetValue(HeaderTextStyleKeyProperty); }
set { SetValue(HeaderTextStyleKeyProperty, value); }
}
// Using a DependencyProperty as the backing store for HeaderTextStyle. This enables animation, styling, binding, etc...
public static readonly DependencyProperty HeaderTextStyleKeyProperty = DependencyProperty.Register("HeaderTextStyleKey", typeof(string),
typeof(RibbonBackstageTabItemHeader), new PropertyMetadata("RibbonBackstageTabItemHeaderLabelStyle",
(sender, e) => ((RibbonBackstageTabItemHeader)sender).BuildHeader()));
private void BuildHeader()
{
var image = new Image
{
Source = Icon,
Style = TryFindResource("RibbonBackstageTabItemHeaderImageStyle") as Style
};
Grid.SetColumn(image, 0);
var label = new Label
{
Content = HeaderText,
Style = TryFindResource(HeaderTextStyleKey) as Style
};
Grid.SetColumn(label, 1);
var size = (Icon != null) || KeepIconSizeWithoutIcon ? 36 : 0;
var grid = new Grid();
grid.ColumnDefinitions.Add(new ColumnDefinition
{
Width = new GridLength(size, GridUnitType.Pixel)
});
grid.ColumnDefinitions.Add(new ColumnDefinition
{
Width = new GridLength(1, GridUnitType.Star),
MinWidth = 200
});
grid.Children.Add(image);
grid.Children.Add(label);
SetCurrentValue(ContentProperty, grid);
}
}
} | 41.581633 | 289 | 0.607607 | [
"MIT"
] | vatsan-madhavan/Orchestra | src/Orchestra.Shell.Ribbon.Fluent/Controls/RibbonBackstageTabItemHeader.cs | 4,077 | C# |
using System;
using System.Collections;
using System.Collections.Generic;
using Unity.MLAgents;
using UnityEngine;
using UnityEngine.AI;
using Random = UnityEngine.Random;
//
using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using UnityEngine;
//
public class Enemy : MonoBehaviour
{
public int startingHealth = 100;
public EnemyManager enemyManager;
public float speed = 1f;
private EnvironmentParameters EnvironmentParameters;
private int CurrentHealth;
private Vector3 StartPosition;
public float randomRangeX_Pos = 0f;
public float randomRangeX_Neg = 0f;
public float randomRangeZ_Pos = 0f;
public float randomRangeZ_Neg = 0f;
public ShootingAgent Agent;
private NavMeshAgent navAgent;
private void Start()
{
StartPosition = transform.position;
CurrentHealth = startingHealth;
EnvironmentParameters = Academy.Instance.EnvironmentParameters;
speed = EnvironmentParameters.GetWithDefault("zombieSpeed", 1f);
navAgent = GetComponent<NavMeshAgent>();
navAgent.speed = speed;
Agent.OnEnvironmentReset += Respawn;
}
private void FixedUpdate()
{
navAgent.destination = Agent.transform.position;
//transform.position = Vector3.MoveTowards(transform.position, Agent.transform.position, Time.fixedDeltaTime * speed);
}
public void GetShot(int damage, ShootingAgent shooter)
{ // AddReward(-1f);
ApplyDamage(damage, shooter);
}
private void ApplyDamage(int damage, ShootingAgent shooter)
{
CurrentHealth -= damage;
if (CurrentHealth <= 0)
{
Die(shooter);
}
}
private void Die(ShootingAgent shooter)
{
shooter.RegisterKill();
gameObject.SetActive(false);
enemyManager.RegisterDeath();
}
public void Respawn()
{
CurrentHealth = startingHealth;
speed = EnvironmentParameters.GetWithDefault("zombieSpeed", 1f);
navAgent.speed = speed;
transform.position = new Vector3(StartPosition.x + Random.Range(randomRangeX_Neg, randomRangeX_Pos), StartPosition.y, StartPosition.z + Random.Range(randomRangeZ_Neg, randomRangeZ_Pos));
}
}
| 27.493976 | 194 | 0.675723 | [
"MIT"
] | ReanSchwarzer1/Covid-AR-Shooting-RL | Android Version/Assets/Scripts/Scripts for ML agents/Enemy.cs | 2,284 | C# |
namespace MyMauiApp;
public partial class MainPage : ContentPage
{
int count = 0;
public MainPage()
{
InitializeComponent();
}
private void OnCounterClicked(object sender, EventArgs e)
{
count++;
CounterLabel.Text = $"Current count: {count}";
SemanticScreenReader.Announce(CounterLabel.Text);
}
}
| 16.095238 | 59 | 0.674556 | [
"MIT"
] | LarsBehl/MauiTapGesture | MainPage.xaml.cs | 340 | C# |
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the \"License\");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an \"AS IS\" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using System;
using System.Text;
using static Google.Ads.GoogleAds.V1.Enums.ExtensionTypeEnum.Types;
using static Google.Ads.GoogleAds.V1.Enums.FeedItemTargetTypeEnum.Types;
using static Google.Ads.GoogleAds.V1.Enums.PlaceholderTypeEnum.Types;
using static Google.Ads.GoogleAds.V1.Enums.SimulationModificationMethodEnum.Types;
using static Google.Ads.GoogleAds.V1.Enums.SimulationTypeEnum.Types;
#pragma warning disable 1591
namespace Google.Ads.GoogleAds.V1.Errors
{
/// <summary>
/// Helper class to generate resource names for various entities.
/// </summary>
public class ResourceNames
{
public static string AccountBudgetProposal(long customerId, long accountBudgetProposalId)
{
return $"customers/{customerId}/accountBudgetProposals/{accountBudgetProposalId}";
}
public static string AdGroup(long customerId, long adGroupId)
{
return $"customers/{customerId}/adGroups/{adGroupId}";
}
public static string AdGroupAd(long customerId, long adGroupId, long adId)
{
return $"customers/{customerId}/adGroupAds/{adGroupId}~{adId}";
}
public static string AdGroupAdLabel(long customerId, long adGroupId, long adId, long labelId)
{
return $"customers/{customerId}/adGroupAdLabels/{adGroupId}~{adId}~{labelId}";
}
public static string AdGroupAudienceView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/adGroupAudienceViews/{adGroupId}~{criterionId}";
}
public static string AdGroupBidModifier(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/adGroupBidModifiers/{adGroupId}~{criterionId}";
}
public static string AdGroupCriterion(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/adGroupCriteria/{adGroupId}~{criterionId}";
}
public static string AdGroupCriterionLabel(long customerId, long adGroupId, long criterionId, long labelId)
{
return $"customers/{customerId}/adGroupCriterionLabels/{adGroupId}~{criterionId}~{labelId}";
}
public static string AdGroupExtensionSetting(long customerId, long adGroupId, ExtensionType extensionType)
{
return $"customers/{customerId}/adGroupExtensionSettings/{adGroupId}~{extensionType}";
}
public static string AdGroupFeed(long customerId, long adGroupId, long feedId)
{
return $"customers/{customerId}/adGroupFeeds/{adGroupId}~{feedId}";
}
public static string AdGroupLabel(long customerId, long adGroupId, long labelId)
{
return $"customers/{customerId}/adGroupLabels/{adGroupId}~{labelId}";
}
public static string AdParameter(long customerId, long adGroupId, long criterionId, long parameterIndex)
{
return $"customers/{customerId}/adParameters/{adGroupId}~{criterionId}~{parameterIndex}";
}
public static string AdScheduleView(long customerId, long campaignId, long criterionId)
{
return $"customers/{customerId}/adScheduleViews/{campaignId}~{criterionId}";
}
public static string AgeRangeView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/ageRangeViews/{adGroupId}~{criterionId}";
}
public static string Asset(long customerId, long assetId)
{
return $"customers/{customerId}/assets/{assetId}";
}
public static string BiddingStrategy(long customerId, long biddingStrategyId)
{
return $"customers/{customerId}/biddingStrategies/{biddingStrategyId}";
}
public static string BillingSetup(long customerId, long billingSetupId)
{
return $"customers/{customerId}/billingSetups/{billingSetupId}";
}
public static string Campaign(long customerId, long campaignId)
{
return $"customers/{customerId}/campaigns/{campaignId}";
}
public static string CampaignAudienceView(long customerId, long campaignId, long criterionId)
{
return $"customers/{customerId}/campaignAudienceViews/{campaignId}~{criterionId}";
}
public static string CampaignBidModifier(long customerId, long campaignId, long criterionId)
{
return $"customers/{customerId}/campaignBidModifiers/{campaignId}~{criterionId}";
}
public static string CampaignBudget(long customerId, long budgetId)
{
return $"customers/{customerId}/campaignBudgets/{budgetId}";
}
public static string CampaignDraft(long customerId, long baseCampaignId, long draftId)
{
return $"customers/{customerId}/campaignDrafts/{baseCampaignId}~{draftId}";
}
public static string CampaignExperiments(long customerId, long campaignExperimentId)
{
return $"customers/{customerId}/campaignExperiments/{campaignExperimentId}";
}
public static string CampaignCriteria(long customerId, long campaignId, long criterionId)
{
return $"customers/{customerId}/campaignCriteria/{campaignId}~{criterionId}";
}
public static string CampaignExtensionSetting(long customerId, long campaignId, ExtensionType extensionType)
{
return $"customers/{customerId}/campaignExtensionSettings/{campaignId}~{extensionType}";
}
public static string CampaignFeed(long customerId, long campaignId, long feedId)
{
return $"customers/{customerId}/campaignFeeds/{campaignId}~{feedId}";
}
public static string CampaignLabel(long customerId, long campaignId, long labelId)
{
return $"customers/{customerId}/campaignLabels/{campaignId}~{labelId}";
}
public static string CampaignSharedSet(long customerId, long campaignId, long sharedSetId)
{
return $"customers/{customerId}/campaignSharedSets/{campaignId}~{sharedSetId}";
}
public static string CarrierConstant(long criterionId)
{
return $"carrierConstants/{criterionId}";
}
public static string ChangeStatus(long customerId, long changeStatusId)
{
return $"customers/{customerId}/changeStatus/{changeStatusId}";
}
public static string ClickView(long customerId, DateTime date, string gclid)
{
return $"customers/{customerId}/clickViews/{date.ToString("yyyy-MM-dd")}~{gclid}";
}
public static string ConversionAction(long customerId, long conversionActionId)
{
return $"customers/{customerId}/conversionActions/{conversionActionId}";
}
public static string CustomInterest(long customerId, long customInterestId)
{
return $"customers/{customerId}/customInterests/{customInterestId}";
}
public static string Customer(long customerId)
{
return $"customers/{customerId}";
}
public static string CustomerClient(long customerId, long clientCustomerId)
{
return $"customers/{customerId}/customerClients/{clientCustomerId}";
}
public static string CustomerClientLink(long customerId, long clientCustomerId, long managerLinkId)
{
return $"customers/{customerId}/customerClientLinks/{clientCustomerId}~{managerLinkId}";
}
public static string CustomerExtensionSetting(long customerId, ExtensionType extensionType)
{
return $"customers/{customerId}/customerExtensionSettings/{extensionType}";
}
public static string CustomerFeed(long customerId, long feedId)
{
return $"customers/{customerId}/customerFeeds/{feedId}";
}
public static string CustomerLabel(long customerId, long labelId)
{
return $"customers/{customerId}/customerLabels/{labelId}";
}
public static string CustomerManagerLink(long customerId, long managerCustomerId, long managerLinkId)
{
return $"customers/{customerId}/customerManagerLinks/{managerCustomerId}~{managerLinkId}";
}
public static string CustomerNegativeCriteria(long customerId, long criterionId)
{
return $"customers/{customerId}/customerNegativeCriteria/{criterionId}";
}
public static string DetailPlacementView(long customerId, long adGroupId, string placement)
{
return $"customers/{customerId}/detailPlacementViews/{adGroupId}~{Base64Encode(placement)}";
}
private static string Base64Encode(string text)
{
return Convert.ToBase64String(Encoding.UTF8.GetBytes(text));
}
public static string DisplayKeywordView(long customerId, long adGroupId, string criterionId)
{
return $"customers/{customerId}/displayKeywordViews/{adGroupId}~{criterionId}";
}
public static string DomainCategorie(long customerId, long campaignId, string category, string languageCode)
{
return $"customers/{customerId}/domainCategories/{campaignId}~{Base64Encode(category)}~{languageCode}";
}
public static string DynamicSearchAdsSearchTermView(long customerId, long adGroupId, string searchTermFp, string headlineFp, string landingPageFp, string pageUrlFp)
{
return $"customers/{customerId}/dynamicSearchAdsSearchTermViews/{adGroupId}~{searchTermFp}~{headlineFp}~{landingPageFp}~{pageUrlFp}";
}
public static string ExtensionFeedItem(long customerId, long feedItemId)
{
return $"customers/{customerId}/extensionFeedItems/{feedItemId}";
}
public static string Feed(long customerId, long feedId)
{
return $"customers/{customerId}/feeds/{feedId}";
}
public static string FeedItem(long customerId, long feedId, long feedItemId)
{
return $"customers/{customerId}/feedItems/{feedId}~{feedItemId}";
}
public static string FeedItemTarget(long customerId, long feedId, long feedItemId, FeedItemTargetType feedItemTargetType, long feedItemTargetId)
{
return $"customers/{customerId}/feedItemTargets/{feedId}~{feedItemId}~{feedItemTargetType}~{feedItemTargetId}";
}
public static string FeedMapping(long customerId, long feedId, long feedMappingId)
{
return $"customers/{customerId}/feedMappings/{feedId}~{feedMappingId}";
}
public static string FeedPlaceholderView(long customerId, PlaceholderType placeholderType)
{
return $"customers/{customerId}/feedPlaceholderViews/{placeholderType}";
}
public static string GenderView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/genderViews/{adGroupId}~{criterionId}";
}
public static string GeoTargetConstant(long geoTargetConstantId)
{
return $"geoTargetConstants/{geoTargetConstantId}";
}
public static string GeographicView(long customerId, long countryCriterionId, string locationType)
{
return $"customers/{customerId}/geographicViews/{countryCriterionId}~{locationType}";
}
public static string GoogleAdsField(string name)
{
return $"googleAdsFields/{name}";
}
public static string GroupPlacementView(long customerId, long adGroupId, string placement)
{
return $"customers/{customerId}/groupPlacementViews/{adGroupId}~{Base64Encode(placement)}";
}
public static string HotelGroupView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/hotelGroupViews/{adGroupId}~{criterionId}";
}
public static string HotelPerformanceView(long customerId)
{
return $"customers/{customerId}/hotelPerformanceView";
}
public static string KeywordPlan(long customerId, long kpPlanId)
{
return $"customers/{customerId}/keywordPlans/{kpPlanId}";
}
public static string KeywordPlanAdGroup(long customerId, long kpAdGroupId)
{
return $"customers/{customerId}/keywordPlanAdGroups/{kpAdGroupId}";
}
public static string KeywordPlanCampaign(long customerId, long kpCampaignId)
{
return $"customers/{customerId}/keywordPlanCampaigns/{kpCampaignId}";
}
public static string KeywordPlanKeyword(long customerId, long kpAdGroupKeywordId)
{
return $"customers/{customerId}/keywordPlanKeywords/{kpAdGroupKeywordId}";
}
public static string KeywordPlanNegativeKeyword(long customerId, long kpNegativeKeywordId)
{
return $"customers/{customerId}/keywordPlanNegativeKeywords/{kpNegativeKeywordId}";
}
public static string KeywordView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/keywordViews/{adGroupId}~{criterionId}";
}
public static string Label(long customerId, long labelId)
{
return $"customers/{customerId}/labels/{labelId}";
}
public static string LanguageConstant(long criterionId)
{
return $"languageConstants/{criterionId}";
}
public static string LocationView(long customerId, long campaignId, long criterionId)
{
return $"customers/{customerId}/locationViews/{campaignId}~{criterionId}";
}
public static string ManagedPlacementView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/managedPlacementViews/{adGroupId}~{criterionId}";
}
public static string MediaFile(long customerId, long mediaFileId)
{
return $"customers/{customerId}/mediaFiles/{mediaFileId}";
}
public static string MerchantCenterLink(long customerId, long merchantCenterId)
{
return $"customers/{customerId}/merchantCenterLinks/{merchantCenterId}";
}
public static string MobileAppCategoryConstant(long mobileAppCategoryId)
{
return $"mobileAppCategoryConstants/{mobileAppCategoryId}";
}
public static string MobileDeviceConstant(long criterionId)
{
return $"mobileDeviceConstants/{criterionId}";
}
public static string MobileDeviceConstant(long customerId, long mutateJobId)
{
return $"customers/{customerId}/mutateJobs/{mutateJobId}";
}
public static string OperatingSystemVersionConstant(long criterionId)
{
return $"operatingSystemVersionConstants/{criterionId}";
}
public static string ParentalStatusView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/parentalStatusViews/{adGroupId}~{criterionId}";
}
public static string PaymentsAccount(long customerId, long paymentsAccountId)
{
return $"customers/{customerId}/paymentsAccounts/{paymentsAccountId}";
}
public static string ProductBiddingCategoryConstant(string country_code, long level, long id)
{
return $"productBiddingCategoryConstants/{country_code}~{level}~{id}";
}
public static string ProductGroupView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/productGroupViews/{adGroupId}~{criterionId}";
}
public static string Recommendation(long customerId, long recommendationId)
{
return $"customers/{customerId}/recommendations/{recommendationId}";
}
public static string RemarketingAction(long customerId, long remarketingActionId)
{
return $"customers/{customerId}/remarketingActions/{remarketingActionId}";
}
public static string SearchTermView(long customerId, long campaignId, long adGroupId, string searchterm)
{
return $"customers/{customerId}/searchTermViews/{campaignId}~{adGroupId}_{Base64Encode(searchterm)}";
}
public static string SharedCriterion(long customerId, long sharedSetId, long criterionId)
{
return $"customers/{customerId}/sharedCriteria/{sharedSetId}~{criterionId}";
}
public static string SharedSet(long customerId, long sharedSetId)
{
return $"customers/{customerId}/sharedSets/{sharedSetId}";
}
public static string ShoppingPerformanceView(long customerId)
{
return $"customers/{customerId}/shoppingPerformanceView";
}
public static string TopicConstant(long topicId)
{
return $"topicConstants/{topicId}";
}
public static string TopicView(long customerId, long adGroupId, long criterionId)
{
return $"customers/{customerId}/topicViews/{adGroupId}~{criterionId}";
}
public static string UserInterest(long customerId, long userInterestId)
{
return $"customers/{customerId}/userInterests/{userInterestId}";
}
public static string UserList(long customerId, long userListId)
{
return $"customers/{customerId}/userLists/{userListId}";
}
public static string Video(long customerId, long videoId)
{
return $"customers/{customerId}/videos/{videoId}";
}
public static string PaidOrganicSearchTermView(long customerId, long campaignId, long adGroupId, string searchterm)
{
return $"customers/{customerId}/paidOrganicSearchTermViews/{campaignId}~{adGroupId}_{Base64Encode(searchterm)}";
}
public static string LandingPageView(long customerId, long campaignId, long adGroupId, string unexpandedFinalUrlFingerprint)
{
return $"customers/{customerId}/landingPageViews/{unexpandedFinalUrlFingerprint}";
}
public static string ExpandedLandingPageView(long customerId, long campaignId, long adGroupId, string expandedFinalUrlFingerprint)
{
return $"customers/{customerId}/expandedLandingPageViews/{expandedFinalUrlFingerprint}";
}
public static string CampaignCriterionSimulation(long customerId, long campaignId, long criterionId, SimulationType type, SimulationModificationMethod modificationMethod, DateTime startDate, DateTime endDate)
{
return $"customers/{customerId}/campaignCriterionSimulations/{campaignId}~{criterionId}~{type}~{modificationMethod}~{startDate.ToString("yyyy-MM-dd")}~{endDate.ToString("yyyy-MM-dd")}";
}
public static string AdGroupSimulation(long customerId, long adGroupId, SimulationType type, SimulationModificationMethod modificationMethod, DateTime startDate, DateTime endDate)
{
return $"customers/{customerId}/adGroupSimulations/{adGroupId}~{type}~{modificationMethod}~{startDate.ToString("yyyy-MM-dd")}~{endDate.ToString("yyyy-MM-dd")}";
}
public static string AdGroupCriterionSimulation(long customerId, long adGroupId, long criterionId, SimulationType type, SimulationModificationMethod modificationMethod, DateTime startDate, DateTime endDate)
{
return $"customers/{customerId}/adGroupCriterionSimulations/{adGroupId}~{criterionId}~{type}~{modificationMethod}~{startDate.ToString("yyyy-MM-dd")}~{endDate.ToString("yyyy-MM-dd")}";
}
}
}
#pragma warning restore 1591
| 40.128155 | 216 | 0.669118 | [
"Apache-2.0"
] | chrisdunelm/google-ads-dotnet | src/V1/ResourceNames.cs | 20,666 | C# |
using System;
namespace Motor.Extensions.Hosting.Abstractions
{
public class TemporaryFailureException : Exception
{
public TemporaryFailureException()
{
}
public TemporaryFailureException(string message) : base(message)
{
}
public TemporaryFailureException(string message, Exception ex) : base(message, ex)
{
}
}
}
| 20.15 | 90 | 0.627792 | [
"MIT"
] | cavus700/motornet | src/Motor.Extensions.Hosting.Abstractions/TemporaryFailureException.cs | 403 | C# |
using Lucene.Net.Support;
using System.Diagnostics.CodeAnalysis;
namespace Lucene.Net.Util
{
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using DataOutput = Lucene.Net.Store.DataOutput;
/// <summary>
/// A <see cref="DataOutput"/> that can be used to build a <see cref="T:byte[]"/>.
/// <para/>
/// @lucene.internal
/// </summary>
public sealed class GrowableByteArrayDataOutput : DataOutput
{
/// <summary>
/// The bytes </summary>
[WritableArray]
[SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
public byte[] Bytes
{
get { return bytes; }
set { bytes = value; }
}
private byte[] bytes;
/// <summary>
/// The length </summary>
public int Length { get; set; }
/// <summary>
/// Create a <see cref="GrowableByteArrayDataOutput"/> with the given initial capacity. </summary>
public GrowableByteArrayDataOutput(int cp)
{
this.bytes = new byte[ArrayUtil.Oversize(cp, 1)];
this.Length = 0;
}
public override void WriteByte(byte b)
{
if (Length >= bytes.Length)
{
bytes = ArrayUtil.Grow(bytes);
}
bytes[Length++] = b;
}
public override void WriteBytes(byte[] b, int off, int len)
{
int newLength = Length + len;
bytes = ArrayUtil.Grow(bytes, newLength);
System.Buffer.BlockCopy(b, off, bytes, Length, len);
Length = newLength;
}
}
} | 34.805556 | 135 | 0.60016 | [
"Apache-2.0"
] | DiogenesPolanco/lucenenet | src/Lucene.Net/Util/GrowableByteArrayDataOutput.cs | 2,506 | C# |
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Reinforced.Tecture.Aspects.DirectSql.Infrastructure;
using Reinforced.Tecture.Query;
namespace Reinforced.Tecture.Aspects.DirectSql
{
/// <summary>
/// Query tooling of DirectSql aspect
/// </summary>
public abstract class Query : QueryAspect
{
/// <summary>
/// Performs SQL query
/// </summary>
/// <typeparam name="T">Result record type</typeparam>
/// <param name="command">SQL command</param>
/// <param name="parameters">Command parameters</param>
/// <returns>Set of deserialized records</returns>
public abstract IEnumerable<T> DoQuery<T>(string command, object[] parameters) where T : class;
/// <summary>
/// Performs SQL query (asynchronously)
/// </summary>
/// <typeparam name="T">Result record type</typeparam>
/// <param name="command">SQL command</param>
/// <param name="parameters">Command parameters</param>
/// <returns>Set of deserialized records</returns>
public abstract Task<IEnumerable<T>> DoQueryAsync<T>(string command, object[] parameters) where T : class;
private SqlToolingWrapper _tooling;
internal SqlToolingWrapper Tooling
{
get
{
if (_tooling == null)
{
_tooling = new SqlToolingWrapper(_runtime, Aux, ServingTypes);
}
return _tooling;
}
}
private readonly IStrokeRuntime _runtime;
internal new Auxilary Aux
{
get { return base.Aux; }
}
/// <inheritdoc />
protected Query(IStrokeRuntime runtime)
{
_runtime = runtime;
}
/// <summary>
/// Gets set of valid types to be used within SQL query
/// </summary>
protected abstract HashSet<Type> ServingTypes { get; }
}
}
| 31.46875 | 114 | 0.581927 | [
"MIT"
] | AxelUser/Reinforced.Tecture | Aspects/Reinforced.Tecture.Aspects.DirectSql/Query.cs | 2,016 | C# |
using System;
using System.IO;
using Microsoft.Toolkit.Uwp.Notifications;
using Microsoft.UI.Xaml;
using Sentry;
using System.Runtime.ExceptionServices;
using System.Security;
using System.Threading.Tasks;
using System.Xml;
using Windows.ApplicationModel;
using Windows.Storage;
using Package = Windows.ApplicationModel.Package;
using UnhandledExceptionEventArgs = Microsoft.UI.Xaml.UnhandledExceptionEventArgs;
// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.
namespace AirMessageWindows
{
/// <summary>
/// Provides application-specific behavior to supplement the default Application class.
/// </summary>
public partial class App : Application
{
private Window m_window;
/// <summary>
/// Initializes the singleton application object. This is the first line of authored code
/// executed, and as such is the logical equivalent of main() or WinMain().
/// </summary>
public App()
{
_ = InitializeSentry();
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used such as when the application is launched to open a specific file.
/// </summary>
/// <param name="args">Details about the launch request and process.</param>
protected override void OnLaunched(LaunchActivatedEventArgs args)
{
m_window = new MainWindow();
m_window.Activate();
//Register for activation events
ActivationHelper.MainWindow = m_window;
ToastNotificationManagerCompat.OnActivated += ActivationHelper.ToastNotificationManagerCompatOnOnActivated;
}
private async Task InitializeSentry()
{
#if !DEBUG
//Load secrets file
var secretsFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///secrets.xml"));
await using var secretsFileStream = await secretsFile.OpenStreamForReadAsync();
XmlDocument secretsXml = new();
secretsXml.Load(secretsFileStream);
//Initialize Sentry
SentrySdk.Init(new SentryOptions
{
Dsn = secretsXml.SelectSingleNode("/xml/sentryDSN")!.InnerText,
Release = "airmessage-windows@" + GetAppVersion()
});
Current.UnhandledException += ExceptionHandler;
#endif
InitializeComponent();
}
[HandleProcessCorruptedStateExceptions, SecurityCritical]
private static void ExceptionHandler(object sender, UnhandledExceptionEventArgs e)
{
// We need to hold the reference, because the Exception property is cleared when accessed.
var exception = e.Exception;
if (exception == null) return;
// Tells Sentry this was an Unhandled Exception
exception.Data[Sentry.Protocol.Mechanism.HandledKey] = false;
exception.Data[Sentry.Protocol.Mechanism.MechanismKey] = "Application.UnhandledException";
SentrySdk.CaptureException(exception);
// Make sure the event is flushed to disk or to Sentry
SentrySdk.FlushAsync(TimeSpan.FromSeconds(3)).Wait();
}
public static string GetAppVersion()
{
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
return string.Format("{0}.{1}.{2}.{3}", version.Major, version.Minor, version.Build, version.Revision);
}
}
}
| 38.265306 | 119 | 0.645867 | [
"Apache-2.0"
] | airmessage/airmessage-web | windows/AirMessageWindows/AirMessageWindows/App.xaml.cs | 3,752 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using AdmInflux.Client.Models;
using Newtonsoft.Json;
namespace AdmInflux.Client
{
public class MeasurementsClient
{
private readonly HttpClient _client;
private readonly InfluxOptions _options;
public MeasurementsClient(HttpClient client, InfluxOptions options)
{
_client = client;
_options = options;
}
public async Task<IList<Measurement>> List(string server, string database)
{
if (string.IsNullOrWhiteSpace(server)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(server));
if (string.IsNullOrWhiteSpace(database)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(database));
if (!_options.TryGetUri(server, out string uri)) return null;
var query = $"{uri}/query?db={database}&q={Uri.EscapeUriString("SHOW MEASUREMENTS")}";
var responseMessage = await _client.GetAsync(query).ConfigureAwait(false);
if (!responseMessage.IsSuccessStatusCode)
{
return null;
}
var json = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
var response = JsonConvert.DeserializeObject<Response>(json);
var series = response.Results?.FirstOrDefault()?.DataSets?.FirstOrDefault(s => s.Name == "measurements");
return series?.Values.Select(v => new Measurement { Server = server, Database = database, Name = v[0]}).ToList();
}
}
} | 42.04878 | 139 | 0.642111 | [
"MPL-2.0",
"MPL-2.0-no-copyleft-exception"
] | RendleLabs/AdmInflux | src/AdmInflux.Client/MeasurementsClient.cs | 1,726 | C# |
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace XFramework.Collections
{
/// <summary>
/// 树
/// </summary>
/// <typeparam name="T">节点存储的数据类型</typeparam>
public class TreeNode<T>
{
private T m_Data;
}
} | 18.733333 | 49 | 0.633452 | [
"Apache-2.0"
] | xdedzl/XFramework | XFramework/Assets/XFramework/Core/Runtime/Tools/Collections/Tree.cs | 303 | C# |
using System;
using System.Collections.Generic;
using System.Text;
using FlubuCore.Context;
using FlubuCore.Tasks;
using FlubuCore.Tasks.Process;
namespace FlubuCore.Azure.Tasks.Batch
{
public partial class AzureBatchApplicationSetTask : ExternalProcessTaskBase<AzureBatchApplicationSetTask>
{
/// <summary>
/// Update properties for a Batch application.
/// </summary>
public AzureBatchApplicationSetTask(string applicationId = null , string name = null , string resourceGroup = null)
{
WithArguments("az batch application set");
WithArguments("--application-id");
if (!string.IsNullOrEmpty(applicationId))
{
WithArguments(applicationId);
}
WithArguments("--name");
if (!string.IsNullOrEmpty(name))
{
WithArguments(name);
}
WithArguments("--resource-group");
if (!string.IsNullOrEmpty(resourceGroup))
{
WithArguments(resourceGroup);
}
}
protected override string Description { get; set; }
/// <summary>
/// Specify to indicate whether packages within the application may be overwritten using the same version string. Specify either 'true' or 'false' to update the property.
/// </summary>
public AzureBatchApplicationSetTask AllowUpdates(string allowUpdates = null)
{
WithArguments("--allow-updates");
if (!string.IsNullOrEmpty(allowUpdates))
{
WithArguments(allowUpdates);
}
return this;
}
/// <summary>
/// The package to use if a client requests the application but does not specify a version.
/// </summary>
public AzureBatchApplicationSetTask DefaultVersion(string defaultVersion = null)
{
WithArguments("--default-version");
if (!string.IsNullOrEmpty(defaultVersion))
{
WithArguments(defaultVersion);
}
return this;
}
/// <summary>
/// The display name for the application.
/// </summary>
public AzureBatchApplicationSetTask DisplayName(string displayName = null)
{
WithArguments("--display-name");
if (!string.IsNullOrEmpty(displayName))
{
WithArguments(displayName);
}
return this;
}
}
}
| 29.941176 | 178 | 0.576817 | [
"MIT"
] | flubu-core/FlubuCore.Azure | FlubuCore.Azure/Tasks/Batch/AzureBatchApplicationSetTask.cs | 2,545 | C# |
using GalaSoft.MvvmLight;
namespace PushkinA.EnglishVocabulary.ViewModel
{
/// <summary>
/// This class contains properties that the main View can data bind to.
/// <para>
/// Use the <strong>mvvminpc</strong> snippet to add bindable properties to this ViewModel.
/// </para>
/// <para>
/// You can also use Blend to data bind with the tool's support.
/// </para>
/// <para>
/// See http://www.galasoft.ch/mvvm
/// </para>
/// </summary>
public class MainViewModel : ViewModelBase
{
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
////if (IsInDesignMode)
////{
//// // Code runs in Blend --> create design time data.
////}
////else
////{
//// // Code runs "for real"
////}
}
}
} | 28.058824 | 95 | 0.509434 | [
"MIT"
] | Perekur/AntonPushkin.EnglishVocabulary | ViewModel/MainViewModel.cs | 954 | C# |
// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------
namespace Microsoft.Azure.IIoT.Services.OpcUa.Twin.v2.Models {
using Microsoft.Azure.IIoT.OpcUa.Twin.Models;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
/// <summary>
/// Result of node browse continuation
/// </summary>
public class BrowseNextResponseApiModel {
/// <summary>
/// Default constructor
/// </summary>
public BrowseNextResponseApiModel() { }
/// <summary>
/// Create from service model
/// </summary>
/// <param name="model"></param>
public BrowseNextResponseApiModel(BrowseNextResultModel model) {
if (model == null) {
throw new ArgumentNullException(nameof(model));
}
ErrorInfo = model.ErrorInfo == null ? null :
new ServiceResultApiModel(model.ErrorInfo);
ContinuationToken = model.ContinuationToken;
References = model.References?
.Select(r => r == null ? null : new NodeReferenceApiModel(r))
.ToList();
}
/// <summary>
/// References, if included, otherwise null.
/// </summary>
[JsonProperty(PropertyName = "references",
NullValueHandling = NullValueHandling.Ignore)]
public List<NodeReferenceApiModel> References { get; set; }
/// <summary>
/// Continuation token if more results pending.
/// </summary>
[JsonProperty(PropertyName = "continuationToken",
NullValueHandling = NullValueHandling.Ignore)]
public string ContinuationToken { get; set; }
/// <summary>
/// Service result in case of error
/// </summary>
[JsonProperty(PropertyName = "errorInfo",
NullValueHandling = NullValueHandling.Ignore)]
public ServiceResultApiModel ErrorInfo { get; set; }
}
}
| 36.442623 | 99 | 0.569501 | [
"MIT"
] | TheWaywardHayward/Industrial-IoT | services/src/Microsoft.Azure.IIoT.Services.OpcUa.Twin/src/v2/Models/BrowseNextResponseApiModel.cs | 2,223 | C# |
using System;
using System.Linq;
using ImageClassification.ImageData;
using System.IO;
using Microsoft.ML;
using static ImageClassification.Model.ConsoleHelpers;
namespace ImageClassification.Model
{
public class ModelScorer
{
private readonly string dataLocation;
private readonly string imagesFolder;
private readonly string modelLocation;
private readonly MLContext mlContext;
public ModelScorer(string dataLocation, string imagesFolder, string modelLocation)
{
this.dataLocation = dataLocation;
this.imagesFolder = imagesFolder;
this.modelLocation = modelLocation;
mlContext = new MLContext(seed: 1);
}
public void ClassifyImages()
{
ConsoleWriteHeader("Loading model");
Console.WriteLine($"Model loaded: {modelLocation}");
// Load the model
ITransformer loadedModel = mlContext.Model.Load(modelLocation,out var modelInputSchema);
// Make prediction function (input = ImageNetData, output = ImageNetPrediction)
var predictor = mlContext.Model.CreatePredictionEngine<ImageNetData, ImageNetPrediction>(loadedModel);
// Read csv file into List<ImageNetData>
var imageListToPredict = ImageNetData.ReadFromCsv(dataLocation, imagesFolder).ToList();
ConsoleWriteHeader("Making classifications");
// There is a bug (https://github.com/dotnet/machinelearning/issues/1138),
// that always buffers the response from the predictor
// so we have to make a copy-by-value op everytime we get a response
// from the predictor
imageListToPredict
.Select(td => new { td, pred = predictor.Predict(td) })
.Select(pr => (pr.td.ImagePath, pr.pred.PredictedLabelValue, pr.pred.Score))
.ToList()
.ForEach(pr => ConsoleWriteImagePrediction(pr.ImagePath, pr.PredictedLabelValue, pr.Score.Max()));
}
}
}
| 40.411765 | 114 | 0.654051 | [
"MIT"
] | AbhiAgarwal192/machinelearning-samples | samples/csharp/getting-started/DeepLearning_TensorFlowEstimator/ImageClassification.Predict/Model/ModelScorer.cs | 2,063 | C# |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Naveego.DataQuality
{
public class VirtualCheckOverride
{
public string ItemId { get; set; }
public string Owner { get; set; }
}
}
| 18.9375 | 43 | 0.660066 | [
"Apache-2.0"
] | Naveego/naveego-net | src/Naveego/DataQuality/VirtualCheckOverride.cs | 305 | C# |
namespace DNASequences
{
using System;
using System.Collections.Generic;
public class DNASequences
{
public static void Main()
{
var charValueDict = new Dictionary<int, char>()
{
{ 1, 'A' },
{ 2, 'C' },
{ 3, 'G' },
{ 4, 'T' }
};
var matchSum = int.Parse(Console.ReadLine());
for (int i = 1; i <= 4; i++)
{
for (int j = 1; j <= 4; j++)
{
for (int k = 1; k <= 4; k++)
{
var currentSum = i + j + k;
if (currentSum >= matchSum)
{
Console.Write($"O{charValueDict[i]}{charValueDict[j]}{charValueDict[k]}O ");
}
else
{
Console.Write($"X{charValueDict[i]}{charValueDict[j]}{charValueDict[k]}X ");
}
}
Console.WriteLine();
}
}
}
}
} | 27.27907 | 104 | 0.326513 | [
"MIT"
] | doba7a/SoftUni | Tech Module/Programming Fundamentals/5. CSharp Basics - More Exercise/6. DNASequences/Program.cs | 1,175 | C# |
using System;
namespace OrdersCollector.Core.Models
{
/// <summary>
/// Holds information about source and user that made changes.
/// </summary>
public class AuditInfo
{
/// <summary>
/// Source. For example: Skype
/// </summary>
public string Source { get; set; }
/// <summary>
/// Sub source. For example skype chat name.
/// </summary>
public string SubSource { get; set; }
/// <summary>
/// SubSubSource. For example skype message id.
/// </summary>
public string SubSubSource { get; set; }
/// <summary>
/// Identifier of the user that caused the change to occur.
/// </summary>
public string InvokedBy { get; set; }
/// <summary>
/// Name of the user that caused the change to occur.
/// </summary>
public string InvokedByName { get; set; }
/// <summary>
/// Operation date.
/// </summary>
public DateTime? Date { get; set; }
}
}
| 25.853659 | 67 | 0.529245 | [
"MIT"
] | jmansar/orders-collector | src/OrdersCollector.Core/Models/AuditInfo.cs | 1,062 | C# |
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Xml;
using Microsoft.Build.BackEnd;
using Microsoft.Build.Collections;
using Microsoft.Build.Construction;
using Microsoft.Build.Engine.UnitTests;
using Microsoft.Build.Engine.UnitTests.Globbing;
using Microsoft.Build.Evaluation;
using Microsoft.Build.Execution;
using Microsoft.Build.Framework;
using Microsoft.Build.Shared;
using InvalidProjectFileException = Microsoft.Build.Exceptions.InvalidProjectFileException;
using NodeLoggingContext = Microsoft.Build.BackEnd.Logging.NodeLoggingContext;
using Xunit;
namespace Microsoft.Build.UnitTests.BackEnd
{
public class IntrinsicTask_Tests
{
[Fact]
public void PropertyGroup()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<p1>v1</p1>
<p2>v2</p2>
</PropertyGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
ExecuteTask(task, LookupHelpers.CreateLookup(properties));
Assert.Equal(2, properties.Count);
Assert.Equal("v1", properties["p1"].EvaluatedValue);
Assert.Equal("v2", properties["p2"].EvaluatedValue);
}
[Fact]
public void PropertyGroupWithComments()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t' >
<PropertyGroup><!-- c -->
<p1>v1</p1><!-- c -->
</PropertyGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
ExecuteTask(task, LookupHelpers.CreateLookup(properties));
Assert.Single(properties);
Assert.Equal("v1", properties["p1"].EvaluatedValue);
}
[Fact]
public void PropertyGroupEmpty()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t' >
<PropertyGroup/>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
ExecuteTask(task, LookupHelpers.CreateLookup(properties));
Assert.Empty(properties);
}
[Fact]
public void PropertyGroupWithReservedProperty()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<MSBuildProjectFile/>
</PropertyGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task);
}
);
}
[Fact]
public void PropertyGroupWithInvalidPropertyName()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(
@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<PropertyGroup/>
</PropertyGroup>
</Target>
</Project>"
);
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task);
}
);
}
[Fact]
public void BlankProperty()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<p1></p1>
</PropertyGroup>
</Target>
</Project>"
);
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
ExecuteTask(task, LookupHelpers.CreateLookup(properties));
Assert.Single(properties);
Assert.Equal("", properties["p1"].EvaluatedValue);
}
[Fact]
public void PropertyGroupWithInvalidSyntax1()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(
@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>x</PropertyGroup>
</Target>
</Project>"
);
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task, null);
}
);
}
[Fact]
public void PropertyGroupWithInvalidSyntax2()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(
@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<p Include='v0'/>
</PropertyGroup>
</Target>
</Project>"
);
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task, null);
}
);
}
[Fact]
public void PropertyGroupWithConditionOnGroup()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup Condition='false'>
<p1>v1</p1>
<p2>v2</p2>
</PropertyGroup>
<Message Text='[$(P1)][$(P2)]'/>
</Target>
</Project>"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogDoesntContain("[v1][v2]");
logger.ClearLog();
p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup Condition='true'>
<p1>v1</p1>
<p2>v2</p2>
</PropertyGroup>
<Message Text='[$(P1)][$(P2)]'/>
</Target>
</Project>"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[v1][v2]");
}
[Fact]
public void PropertyGroupWithConditionOnGroupUsingMetadataErrors()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup Condition=""'%(i0.m)'=='m2'"">
<p1>@(i0)</p1>
<p2>%(i0.m)</p2>
</PropertyGroup>
</Target>
</Project>"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("MSB4191"); // Metadata not allowed
}
[Fact]
public void ItemGroup()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i2 Include='b1'/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Equal("a1", i1Group.First().EvaluatedInclude);
Assert.Equal("b1", i2Group.First().EvaluatedInclude);
}
internal const string TargetitemwithIncludeAndExclude = @"
<Project>
<Target Name=`t`>
<ItemGroup>
<i Include='{0}' Exclude='{1}'/>
</ItemGroup>
</Target>
</Project>
";
public static IEnumerable<object[]> IncludesAndExcludesWithWildcardsTestData => GlobbingTestData.IncludesAndExcludesWithWildcardsTestData;
[Theory]
[MemberData(nameof(IncludesAndExcludesWithWildcardsTestData))]
public void ItemsWithWildcards(string includeString, string excludeString, string[] inputFiles, string[] expectedInclude, bool makeExpectedIncludeAbsolute)
{
var projectContents = string.Format(TargetitemwithIncludeAndExclude, includeString, excludeString).Cleanup();
AssertItemEvaluationFromTarget(projectContents, "t", "i", inputFiles, expectedInclude, makeExpectedIncludeAbsolute, normalizeSlashes: true);
}
[Fact]
public void ItemKeepDuplicatesEmptySameAsTrue()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1 Include='a1' KeepDuplicates='' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i1");
Assert.Equal(2, group.Count);
}
[Fact]
public void ItemKeepDuplicatesFalse()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1 Include='a1' KeepDuplicates='false' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i1");
Assert.Single(group);
}
[Fact]
public void ItemKeepDuplicatesAsCondition()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1 Include='a1' KeepDuplicates="" '$(Keep)' == 'true' "" />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i1");
Assert.Single(group);
}
[Fact]
public void ItemKeepDuplicatesFalseKeepsExistingDuplicates()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1 Include='a1'/>
<i1 Include='a1' KeepDuplicates='false' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i1");
Assert.Equal(2, group.Count);
}
[Fact]
public void ItemKeepDuplicatesFalseDuringCopyEliminatesDuplicates()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1 Include='a1'/>
<i2 Include='@(i1)' KeepDuplicates='false' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i1");
Assert.Equal(2, group.Count);
group = lookup.GetItems("i2");
Assert.Single(group);
}
[Fact]
public void ItemKeepDuplicatesFalseWithMetadata()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
</i1>
<i1 Include='a2' KeepDuplicates='false' />
<i1 Include='a1' KeepDuplicates='false'>
<m1>m1</m1>
</i1>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i1");
Assert.Equal(2, group.Count);
}
[Fact]
public void ItemKeepMetadataEmptySameAsKeepAll()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
</i1>
<i2 Include='@(i1)' KeepMetadata='' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i2");
Assert.Equal("m1", group.First().GetMetadataValue("m1"));
}
[Fact]
public void ItemKeepMetadata()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
<m2>m2</m2>
<m3>m3</m3>
</i1>
<i2 Include='@(i1)' KeepMetadata='m2' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i2");
Assert.Equal(String.Empty, group.First().GetMetadataValue("m1"));
Assert.Equal("m2", group.First().GetMetadataValue("m2"));
Assert.Equal(String.Empty, group.First().GetMetadataValue("m3"));
}
[Fact]
public void ItemKeepMetadataNotExistant()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
<m2>m2</m2>
<m3>m3</m3>
</i1>
<i2 Include='@(i1)' KeepMetadata='NONEXISTANT' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i2");
Assert.Equal(String.Empty, group.First().GetMetadataValue("m1"));
Assert.Equal(String.Empty, group.First().GetMetadataValue("m2"));
Assert.Equal(String.Empty, group.First().GetMetadataValue("m3"));
}
[Fact]
public void ItemKeepMetadataList()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
<m2>m2</m2>
<m3>m3</m3>
</i1>
<i2 Include='@(i1)' KeepMetadata='m1;m2' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i2");
Assert.Equal("m1", group.First().GetMetadataValue("m1"));
Assert.Equal("m2", group.First().GetMetadataValue("m2"));
Assert.Equal(String.Empty, group.First().GetMetadataValue("m3"));
}
[Fact]
public void ItemKeepMetadataListExpansion()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
<m2>m2</m2>
<m3>m3</m3>
</i1>
<i2 Include='@(i1)' KeepMetadata='$(Keep)' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
var scope = lookup.EnterScope("test");
lookup.SetProperty(ProjectPropertyInstance.Create("Keep", "m1;m2"));
ExecuteTask(task, lookup);
scope.LeaveScope();
var group = lookup.GetItems("i2");
Assert.Equal("m1", group.First().GetMetadataValue("m1"));
Assert.Equal("m2", group.First().GetMetadataValue("m2"));
Assert.Equal(String.Empty, group.First().GetMetadataValue("m3"));
}
[Fact]
public void ItemRemoveMetadataEmptySameAsKeepAll()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
</i1>
<i2 Include='@(i1)' RemoveMetadata='' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i2");
Assert.Equal("m1", group.First().GetMetadataValue("m1"));
}
[Fact]
public void ItemRemoveMetadata()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
<m2>m2</m2>
<m3>m3</m3>
</i1>
<i2 Include='@(i1)' RemoveMetadata='m2' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i2");
Assert.Equal("m1", group.First().GetMetadataValue("m1"));
Assert.Equal(String.Empty, group.First().GetMetadataValue("m2"));
Assert.Equal("m3", group.First().GetMetadataValue("m3"));
}
[Fact]
public void ItemRemoveMetadataList()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
<m2>m2</m2>
<m3>m3</m3>
</i1>
<i2 Include='@(i1)' RemoveMetadata='m1;m2' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
var group = lookup.GetItems("i2");
Assert.Equal(String.Empty, group.First().GetMetadataValue("m1"));
Assert.Equal(String.Empty, group.First().GetMetadataValue("m2"));
Assert.Equal("m3", group.First().GetMetadataValue("m3"));
}
[Fact]
public void ItemRemoveMetadataListExpansion()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
<m2>m2</m2>
<m3>m3</m3>
</i1>
<i2 Include='@(i1)' RemoveMetadata='$(Remove)' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
var scope = lookup.EnterScope("test");
lookup.SetProperty(ProjectPropertyInstance.Create("Remove", "m1;m2"));
ExecuteTask(task, lookup);
scope.LeaveScope();
var group = lookup.GetItems("i2");
Assert.Equal(String.Empty, group.First().GetMetadataValue("m1"));
Assert.Equal(String.Empty, group.First().GetMetadataValue("m2"));
Assert.Equal("m3", group.First().GetMetadataValue("m3"));
}
[Fact]
public void ItemKeepMetadataAndRemoveMetadataMutuallyExclusive()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m1>m1</m1>
<m2>m2</m2>
<m3>m3</m3>
</i1>
<i2 Include='@(i1)' KeepMetadata='m1' RemoveMetadata='m2' />
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
}
);
}
/// <summary>
/// Should not make items with an empty include.
/// </summary>
[Fact]
public void ItemGroupWithPropertyExpandingToNothing()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='$(xxx)'/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
Assert.Empty(i1Group);
}
[Fact]
public void ItemGroupWithComments()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup> <!-- c -->
<i1 Include='a1;a2'/> <!-- c -->
<ii Remove='a1'/> <!-- c -->
<i1> <!-- c -->
<m>m1</m> <!-- c -->
</i1> <!-- c -->
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
Assert.Equal("a1", i1Group.First().EvaluatedInclude);
Assert.Equal("m1", i1Group.First().GetMetadataValue("m"));
}
/// <summary>
/// This is something that used to be done by CreateItem
/// </summary>
[Fact]
public void ItemGroupTrims()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include=' $(p0) '/>
<i2 Include='b1'/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
properties.Set(ProjectPropertyInstance.Create("p0", " v0 "));
Lookup lookup = LookupHelpers.CreateLookup(properties);
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
Assert.Equal("v0", i1Group.First().EvaluatedInclude);
}
[Fact]
public void ItemGroupWithInvalidSyntax1()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>x</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task, null);
}
);
}
[Fact]
public void ItemGroupWithInvalidSyntax2()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i>x</i>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task, null);
}
);
}
[Fact]
public void ItemGroupWithInvalidSyntax3()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i Include='x' Exclude='y' Remove='z'/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task, null);
}
);
}
[Fact]
public void ItemGroupWithTransform()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a.cpp'/>
<i2 Include=""@(i1->'%(filename).obj')""/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Equal("a.cpp", i1Group.First().EvaluatedInclude);
Assert.Equal("a.obj", i2Group.First().EvaluatedInclude);
}
[Fact]
public void ItemGroupWithTransformInMetadataValue()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a.cpp'/>
<i2 Include='@(i1)'>
<m>@(i1->'%(filename).obj')</m>
</i2>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Equal("a.cpp", i2Group.First().EvaluatedInclude);
Assert.Equal("a.obj", i2Group.First().GetMetadataValue("m"));
}
[Fact]
public void ItemGroupWithExclude()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i2 Include='a1;@(i1);b1;b2' Exclude='@(i1);b1'/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Equal("a1", i1Group.First().EvaluatedInclude);
Assert.Equal("b2", i2Group.First().EvaluatedInclude);
}
[Fact]
public void ItemGroupWithMetadataInExclude()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>a1</m>
</i1>
<i2 Include='b1;@(i1)' Exclude='%(i1.m)'/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Single(i1Group);
Assert.Single(i2Group);
Assert.Equal("a1", i1Group.First().EvaluatedInclude);
Assert.Equal("b1", i2Group.First().EvaluatedInclude);
}
[Fact]
public void ItemGroupWithConditionOnGroup()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup Condition='false'>
<i1 Include='a1'/>
<i2 Include='b1'/>
</ItemGroup>
<Message Text='[@(i1)][@(i2)]'/>
</Target>
</Project>"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogDoesntContain("[a1][b1]");
logger.ClearLog();
p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup Condition='true'>
<i1 Include='a1'/>
<i2 Include='b1'/>
</ItemGroup>
<Message Text='[@(i1)][@(i2)]'/>
</Target>
</Project>"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[a1][b1]");
}
[Fact]
public void ItemGroupWithConditionOnGroupUsingMetadataErrors()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup Condition=""'%(i0.m)'!='m1'"">
<i1 Include='a1'/>
<i2 Include='%(i0.m)'/>
<i3 Include='%(i0.identity)'/>
<i4 Include='@(i0)'/>
</ItemGroup>
</Target>
</Project>"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("MSB4191"); // Metadata not allowed
}
[Fact]
public void PropertyGroupWithExternalPropertyReferences()
{
// <PropertyGroup>
// <p0>v0</p0>
// </PropertyGroup>
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<p1>$(p0)</p1>
</PropertyGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = GeneratePropertyGroup();
ExecuteTask(task, LookupHelpers.CreateLookup(properties));
Assert.Equal(2, properties.Count);
Assert.Equal("v0", properties["p0"].EvaluatedValue);
Assert.Equal("v0", properties["p1"].EvaluatedValue);
}
[Fact]
public void ItemGroupWithPropertyReferences()
{
// <PropertyGroup>
// <p0>v0</p0>
// </PropertyGroup>
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='$(p0)'/>
<i2 Include='a2'/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = GeneratePropertyGroup();
Lookup lookup = LookupHelpers.CreateLookup(properties);
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Equal("v0", i1Group.First().EvaluatedInclude);
Assert.Equal("a2", i2Group.First().EvaluatedInclude);
}
[Fact]
public void ItemGroupWithMetadataReferences()
{
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1 Include='a2'>
<m>m2</m>
</i1>
<i2 Include='%(i1.m)'/>
</ItemGroup>
</Target>
</Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Equal("a1", i1Group.First().EvaluatedInclude);
Assert.Equal("a2", i1Group.ElementAt(1).EvaluatedInclude);
Assert.Equal("m1", i2Group.First().EvaluatedInclude);
Assert.Equal("m2", i2Group.ElementAt(1).EvaluatedInclude);
Assert.Equal("m1", i1Group.First().GetMetadataValue("m"));
Assert.Equal("m2", i1Group.ElementAt(1).GetMetadataValue("m"));
}
[Fact]
public void ItemGroupWithMetadataReferencesOnMetadataConditions()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1 Include='a2'>
<m>m2</m>
</i1>
<i2 Include='@(i1)'>
<n Condition=""'%(i1.m)'=='m1'"">n1</n>
</i2>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Equal(2, i2Group.Count);
Assert.Equal("a1", i2Group.First().EvaluatedInclude);
Assert.Equal("a2", i2Group.ElementAt(1).EvaluatedInclude);
Assert.Equal("n1", i2Group.First().GetMetadataValue("n"));
Assert.Equal(String.Empty, i2Group.ElementAt(1).GetMetadataValue("n"));
}
[Fact]
public void ItemGroupWithMetadataReferencesOnItemGroupAndItemConditionsErrors()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup Condition=""'%(i0.m)' != m1"" >
<i1 Include=""%(m)"" Condition=""'%(i0.m)' != m3""/>
</ItemGroup>
</Target></Project>"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("MSB4191"); // Metadata not allowed
}
[Fact]
public void ItemGroupWithExternalMetadataReferences()
{
// <ItemGroup>
// <i0 Include='a1'>
// <m>m1</m>
// </i0>
// <i0 Include='a2;a3'>
// <m>m2</m>
// </i0>
// <i0 Include='a4'>
// <m>m3</m>
// </i0>
// </ItemGroup>
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='b1'>
<m>%(i0.m)</m>
</i1>
<i2 Include='%(i1.m)'/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = GenerateLookup(task.Project);
ExecuteTask(task, lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
Assert.Equal("b1", i1Group.First().EvaluatedInclude);
Assert.Equal("b1", i1Group.ElementAt(1).EvaluatedInclude);
Assert.Equal("b1", i1Group.ElementAt(2).EvaluatedInclude);
Assert.Equal("m1", i1Group.First().GetMetadataValue("m"));
Assert.Equal("m2", i1Group.ElementAt(1).GetMetadataValue("m"));
Assert.Equal("m3", i1Group.ElementAt(2).GetMetadataValue("m"));
Assert.Equal("m1", i2Group.First().EvaluatedInclude);
Assert.Equal("m2", i2Group.ElementAt(1).EvaluatedInclude);
Assert.Equal("m3", i2Group.ElementAt(2).EvaluatedInclude);
}
[Fact]
public void PropertyGroupWithCumulativePropertyReferences()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<p1>v1</p1>
<p2>#$(p1)#</p2>
<p1>v2</p1>
</PropertyGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
ExecuteTask(task, LookupHelpers.CreateLookup(properties));
Assert.Equal(2, properties.Count);
Assert.Equal("v2", properties["p1"].EvaluatedValue);
Assert.Equal("#v1#", properties["p2"].EvaluatedValue);
}
[Fact]
public void PropertyGroupWithMetadataReferencesOnGroupErrors()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup Condition=""'%(i0.m)' != m1"">
<p1>%(i0.m)</p1>
</PropertyGroup>
</Target></Project>"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("MSB4191");
}
[Fact]
public void PropertyGroupWithMetadataReferencesOnProperty()
{
// <ItemGroup>
// <i0 Include='a1'>
// <m>m1</m>
// <n>n1</n>
// </i0>
// <i0 Include='a2;a3'>
// <m>m2</m>
// <n>n2</n>
// </i0>
// <i0 Include='a4'>
// <m>m3</m>
// <n>n3</n>
// </i0>
// </ItemGroup>
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<p1 Condition=""'%(i0.n)' != n3"">%(i0.n)</p1>
</PropertyGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = GenerateLookup(task.Project);
ExecuteTask(task, lookup);
Assert.Equal("n2", lookup.GetProperty("p1").EvaluatedValue);
}
[Fact]
public void PropertiesCanReferenceItemsInSameTarget()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1;a2'/>
</ItemGroup>
<PropertyGroup>
<p>@(i1->'#%(identity)#', '*')</p>
</PropertyGroup>
<Message Text='[$(p)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[#a1#*#a2#]");
}
[Fact]
public void ItemsCanReferencePropertiesInSameTarget()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<p0>v0</p0>
</PropertyGroup>
<ItemGroup>
<i1 Include='$(p0)'/>
</ItemGroup>
<Message Text='[@(i1)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[v0]");
}
[Fact]
public void PropertyGroupInTargetCanOverwriteGlobalProperties()
{
MockLogger logger = new MockLogger();
Dictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
globalProperties.Add("global", "v0");
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<PropertyGroup>
<global>v1</global>
</PropertyGroup>
<Target Name='t2' DependsOnTargets='t'>
<Message Text='final:[$(global)]'/>
</Target>
<Target Name='t'>
<Message Text='start:[$(global)]'/>
<PropertyGroup>
<global>v2</global>
</PropertyGroup>
<Message Text='end:[$(global)]'/>
</Target>
</Project>
"))), globalProperties, ObjectModelHelpers.MSBuildDefaultToolsVersion);
ProjectInstance p = project.CreateProjectInstance();
Assert.Equal("v0", p.GetProperty("global").EvaluatedValue);
p.Build(new string[] { "t2" }, new ILogger[] { logger });
// PropertyGroup outside of target can't overwrite global property,
// but PropertyGroup inside of target can overwrite it
logger.AssertLogContains("start:[v0]", "end:[v2]", "final:[v2]");
Assert.Equal("v2", p.GetProperty("global").EvaluatedValue);
// Resetting the project goes back to the old value
p = project.CreateProjectInstance();
Assert.Equal("v0", p.GetProperty("global").EvaluatedValue);
}
[Fact]
public void PropertiesAreRevertedAfterBuild()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<PropertyGroup>
<p>p0</p>
</PropertyGroup>
<Target Name='t'>
<PropertyGroup>
<p>p1</p>
</PropertyGroup>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t" }, new ILogger[] { logger });
string value = p.GetProperty("p").EvaluatedValue;
Assert.Equal("p1", value);
p = project.CreateProjectInstance();
value = p.GetProperty("p").EvaluatedValue;
Assert.Equal("p0", value);
}
[Fact]
public void PropertiesVisibleToSubsequentTask()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup>
<p>p1</p>
</PropertyGroup>
<Message Text='[$(p)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[p1]");
}
[Fact]
public void PropertiesVisibleToSubsequentTarget()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t2' DependsOnTargets='t'>
<Message Text='[$(p)]'/>
</Target>
<Target Name='t'>
<PropertyGroup>
<p>p1</p>
</PropertyGroup>
</Target>
</Project>
"))));
p.Build(new string[] { "t2" }, new ILogger[] { logger });
logger.AssertLogContains("[p1]");
}
[Fact]
public void ItemsVisibleToSubsequentTask()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<Message Text='[@(i)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[i1]");
}
[Fact]
public void ItemsVisibleToSubsequentTarget()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t2' DependsOnTargets='t'>
<Message Text='[@(i)]'/>
</Target>
<Target Name='t'>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
</Target>
</Project>
"))));
p.Build(new string[] { "t2" }, new ILogger[] { logger });
logger.AssertLogContains("[i1]");
}
[Fact]
public void ItemsNotVisibleToParallelTargetBatches()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='1.in'><output>1.out</output></i>
<i Include='2.in'><output>2.out</output></i>
</ItemGroup>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
<Message Text='start:[@(i)]'/>
<ItemGroup>
<j Include='%(i.identity)'/>
</ItemGroup>
<Message Text='end:[@(j)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "start:[1.in]", "end:[1.in]", "start:[2.in]", "end:[2.in]" });
}
[Fact]
public void PropertiesNotVisibleToParallelTargetBatches()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='1.in'><output>1.out</output></i>
<i Include='2.in'><output>2.out</output></i>
</ItemGroup>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
<Message Text='start:[$(p)]'/>
<PropertyGroup>
<p>p1</p>
</PropertyGroup>
<Message Text='end:[$(p)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "start:[]", "end:[p1]", "start:[]", "end:[p1]" });
}
// One input is built, the other is inferred
[Fact]
public void ItemsInPartialBuild()
{
string[] oldFiles = null, newFiles = null;
try
{
oldFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2005, 1, 1));
newFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2006, 1, 1));
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='" + oldFiles.First() + "'><output>" + newFiles.First() + @"</output></i>
<i Include='" + newFiles.ElementAt(1) + "'><output>" + oldFiles.ElementAt(1) + @"</output></i>
</ItemGroup>
<Target Name='t2' DependsOnTargets='t'>
<Message Text='final:[@(j)]'/>
</Target>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.Output)'>
<Message Text='start:[@(j)]'/>
<ItemGroup>
<j Include='%(i.identity)'/>
</ItemGroup>
<Message Text='end:[@(j)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t2" }, new ILogger[] { logger });
// We should only see messages for the out of date inputs, but the itemgroup should do its work for both inputs
logger.AssertLogContains(new string[] { "start:[]", "end:[" + newFiles.ElementAt(1) + "]", "final:[" + oldFiles.First() + ";" + newFiles.ElementAt(1) + "]" });
}
finally
{
ObjectModelHelpers.DeleteTempFiles(oldFiles);
ObjectModelHelpers.DeleteTempFiles(newFiles);
}
}
// One input is built, the other input is inferred
[Fact]
public void PropertiesInPartialBuild()
{
string[] oldFiles = null, newFiles = null;
try
{
oldFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2005, 1, 1));
newFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2006, 1, 1));
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='" + oldFiles.First() + "'><output>" + newFiles.First() + @"</output></i>
<i Include='" + newFiles.ElementAt(1) + "'><output>" + oldFiles.ElementAt(1) + @"</output></i>
</ItemGroup>
<Target Name='t2' DependsOnTargets='t'>
<Message Text='final:[$(p)]'/>
</Target>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.Output)'>
<Message Text='start:[$(p)]'/>
<PropertyGroup>
<p>@(i)</p>
</PropertyGroup>
<Message Text='end:[$(p)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t2" }, new ILogger[] { logger });
// We should only see messages for the out of date inputs, but the propertygroup should do its work for both inputs
// Finally, execution wins over inferral, as the code chooses to do it that way
logger.AssertLogContains(new string[] { "start:[]", "end:[" + newFiles.ElementAt(1) + "]", "final:[" + newFiles.ElementAt(1) + "]" });
}
finally
{
ObjectModelHelpers.DeleteTempFiles(oldFiles);
ObjectModelHelpers.DeleteTempFiles(newFiles);
}
}
// One input is built, the other is inferred
[Fact]
public void ItemsInPartialBuildVisibleToSubsequentlyInferringTasks()
{
string[] oldFiles = null, newFiles = null;
try
{
oldFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2005, 1, 1));
newFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2006, 1, 1));
string oldInput = oldFiles.First();
string newInput = newFiles.ElementAt(1);
string oldOutput = oldFiles.ElementAt(1);
string newOutput = newFiles.First();
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='" + oldInput + "'><output>" + newOutput + @"</output></i>
<i Include='" + newInput + "'><output>" + oldOutput + @"</output></i>
</ItemGroup>
<Target Name='t2' DependsOnTargets='t'>
<Message Text='final:[@(i)]'/>
</Target>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.Output)'>
<Message Text='start:[@(i)]'/>
<ItemGroup>
<j Include='%(i.identity)'/>
</ItemGroup>
<Message Text='middle:[@(i)][@(j)]'/>
<CreateItem Include='@(j)'>
<Output TaskParameter='Include' ItemName='i'/>
</CreateItem>
<Message Text='end:[@(i)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t2" }, new ILogger[] { logger });
// We should only see messages for the out of date inputs, but the itemgroup should do its work for both inputs;
// The final result should include the out of date inputs (twice) and the up to date inputs (twice).
// NOTE: outputs from regular tasks, like CreateItem, are gathered up and included in the project in the order (1) inferred (2) executed.
// Intrinsic tasks, because they affect the project directly, don't do this. So the final order we see is
// two inputs (old, new) from the ItemGroup; followed by the inferred CreateItem output, then the executed CreateItem output.
// I suggest this ordering isn't important: it's a new feature, so nobody will get broken.
logger.AssertLogContains(new string[] { "start:[" + newInput + "]",
"middle:[" + newInput + "][" + newInput + "]",
"end:[" + newInput + ";" + newInput + "]",
"final:[" + oldInput + ";" + newInput + ";" + oldInput + ";" + newInput + "]" });
}
finally
{
ObjectModelHelpers.DeleteTempFiles(oldFiles);
ObjectModelHelpers.DeleteTempFiles(newFiles);
}
}
[Fact]
public void IncludeNoOp()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include=''/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task, null);
}
);
}
[Fact]
public void RemoveNoOp()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Remove='a1'/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
Assert.Empty(lookup.GetItems("i1"));
}
[Fact]
public void RemoveItemInTarget()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1 Remove='a1'/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
Assert.Empty(lookup.GetItems("i1"));
}
/// <summary>
/// Removes in one batch should never affect adds in a parallel batch, even if that
/// parallel batch ran first.
/// </summary>
[Fact]
public void RemoveOfItemAddedInTargetByParallelTargetBatchDoesNothing()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<!-- just to cause two target batches -->
<i Include='1.in'><output>1.out</output></i>
<i Include='2.in'><output>2.out</output></i>
</ItemGroup>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
<ItemGroup>
<j Include='a' Condition=""'%(i.Identity)'=='1.in'""/>
<j Remove='a' Condition=""'%(i.Identity)'=='2.in'""/>
<!-- and again in reversed batch order, in case the engine batches the other way around -->
<j Include='b' Condition=""'%(i.Identity)'=='2.in'""/>
<j Remove='b' Condition=""'%(i.Identity)'=='1.in'""/>
<!-- but obviously a remove in the same batch works -->
<j Include='c' Condition=""'%(i.Identity)'=='2.in'""/>
<j Remove='c' Condition=""'%(i.Identity)'=='2.in'""/>
<!-- unless it's before the add -->
<j Remove='d' Condition=""'%(i.Identity)'=='2.in'""/>
<j Include='d' Condition=""'%(i.Identity)'=='2.in'""/>
</ItemGroup>
</Target>
<Target Name='t2'>
<Message Text='final:[@(j)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t", "t2" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "final:[a;b;d]" });
}
[Fact]
public void RemoveItemInTargetWithTransform()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i0 Include='a.cpp;b.cpp'/>
<i1 Include='a.obj;b.obj'/>
<i1 Remove=""@(i0->'%(filename).obj')""/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
Assert.Empty(lookup.GetItems("i1"));
}
[Fact]
public void RemoveWithMultipleIncludes()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1 Include='a2'/>
<i1 Remove='a1;a2'/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
Assert.Empty(lookup.GetItems("i1"));
}
[Fact]
public void RemoveAllItemsInList()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1 Include='a2'/>
<i1 Remove='@(i1)'/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
Assert.Empty(lookup.GetItems("i1"));
}
[Fact]
public void RemoveItemOutsideTarget()
{
// <ItemGroup>
// <i0 Include='a1'>
// <m>m1</m>
// <n>n1</n>
// </i0>
// <i0 Include='a2;a3'>
// <m>m2</m>
// <n>n2</n>
// </i0>
// <i0 Include='a4'>
// <m>m3</m>
// <n>n3</n>
// </i0>
// </ItemGroup>
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i0 Remove='a2'/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = GenerateLookup(task.Project);
task.ExecuteTask(lookup);
ICollection<ProjectItemInstance> i0Group = lookup.GetItems("i0");
Assert.Equal(3, i0Group.Count);
Assert.Equal("a1", i0Group.First().EvaluatedInclude);
Assert.Equal("a3", i0Group.ElementAt(1).EvaluatedInclude);
Assert.Equal("a4", i0Group.ElementAt(2).EvaluatedInclude);
}
/// <summary>
/// Bare (batchable) metadata is prohibited on IG/PG conditions -- all other expressions
/// should be allowed
/// </summary>
[Fact]
public void ConditionOnPropertyGroupUsingPropertiesAndItemListsAndTransforms()
{
// <ItemGroup>
// <i0 Include='a1'>
// <m>m1</m>
// </i0>
// <i0 Include='a2;a3'>
// <m>m2</m>
// </i0>
// <i0 Include='a4'>
// <m>m3</m>
// </i0>
// </ItemGroup>
// <PropertyGroup>
// <p0>v0</p0>
// </PropertyGroup>
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<PropertyGroup Condition=""'$(p0)'=='v0' and '@(i0)'=='a1;a2;a3;a4' and '@(i0->'%(identity).x','|')'=='a1.x|a2.x|a3.x|a4.x'"">
<p1>v1</p1>
</PropertyGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = GenerateLookupWithItemsAndProperties(task.Project);
task.ExecuteTask(lookup);
string p1 = lookup.GetProperty("p1").EvaluatedValue;
Assert.Equal("v1", p1);
}
/// <summary>
/// Bare (batchable) metadata is prohibited on IG/PG conditions -- all other expressions
/// should be allowed
/// </summary>
[Fact]
public void ConditionOnItemGroupUsingPropertiesAndItemListsAndTransforms()
{
// <ItemGroup>
// <i0 Include='a1'>
// <m>m1</m>
// </i0>
// <i0 Include='a2;a3'>
// <m>m2</m>
// </i0>
// <i0 Include='a4'>
// <m>m3</m>
// </i0>
// </ItemGroup>
// <PropertyGroup>
// <p0>v0</p0>
// </PropertyGroup>
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup Condition=""'$(p0)'=='v0' and '@(i0)'=='a1;a2;a3;a4' and '@(i0->'%(identity).x','|')'=='a1.x|a2.x|a3.x|a4.x'"">
<i1 Include='x'/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = GenerateLookupWithItemsAndProperties(task.Project);
task.ExecuteTask(lookup);
ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
Assert.Single(i1Group);
Assert.Equal("x", i1Group.First().EvaluatedInclude);
}
/// <summary>
/// This bug was caused by batching over the ItemGroup as well as over each child.
/// If the condition on a child did not exclude it, an unwitting child could be included multiple times,
/// once for each outer batch. The fix was to abandon the idea of outer batching and just
/// prohibit batchable expressions on the ItemGroup conditions. It's just too hard to write such expressions
/// in a comprehensible way.
/// </summary>
[Fact]
public void RegressPCHBug()
{
// <ItemGroup>
// <i0 Include='a1'>
// <m>m1</m>
// </i0>
// <i0 Include='a2;a3'>
// <m>m2</m>
// </i0>
// <i0 Include='a4'>
// <m>m3</m>
// </i0>
// </ItemGroup>
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<!-- squint and pretend i0 is 'CppCompile' and 'm' is 'ObjectFile' -->
<Link Include=""A_PCH""/>
<Link Include=""@(i0->'%(m).obj')"" Condition=""'%(i0.m)' == 'm1'""/>
<Link Include=""@(i0->'%(m)')"" Condition=""'%(i0.m)' == 'm2'""/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = GenerateLookup(task.Project);
task.ExecuteTask(lookup);
ICollection<ProjectItemInstance> linkGroup = lookup.GetItems("link");
Assert.Equal(4, linkGroup.Count);
Assert.Equal("A_PCH", linkGroup.First().EvaluatedInclude);
Assert.Equal("m1.obj", linkGroup.ElementAt(1).EvaluatedInclude);
Assert.Equal("m2", linkGroup.ElementAt(2).EvaluatedInclude);
Assert.Equal("m2", linkGroup.ElementAt(3).EvaluatedInclude);
}
[Fact]
public void RemovesOfPersistedItemsAreReversed()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='a1'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i0 Remove='a1'/>
</ItemGroup>
<Message Text='[@(i0)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t" }, new ILogger[] { logger });
// The item was removed during the build
logger.AssertLogContains("[]");
Assert.Empty(p.ItemsToBuildWith["i0"]);
Assert.Empty(p.ItemsToBuildWith.ItemTypes);
p = project.CreateProjectInstance();
// We should still have the item left
Assert.Single(p.ItemsToBuildWith["i0"]);
Assert.Single(p.ItemsToBuildWith.ItemTypes);
}
[Fact]
public void RemovesOfPersistedItemsAreReversed1()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='a1'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i0 Include='a1'/>
<i0 Remove='a1'/>
</ItemGroup>
<Message Text='[@(i0)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[]");
Assert.Empty(p.ItemsToBuildWith["i0"]);
Assert.Empty(p.ItemsToBuildWith.ItemTypes);
p = project.CreateProjectInstance();
// We should still have the item left
Assert.Single(p.ItemsToBuildWith["i0"]);
Assert.Single(p.ItemsToBuildWith.ItemTypes);
}
[Fact]
public void RemovesOfPersistedItemsAreReversed2()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='a1'/>
<i0 Include='a2'/>
<i1 Include='b1'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i0 Include='a1'/>
<i0 Remove='a1'/>
<i0 Include='a1'/>
<i0 Include='a3'/>
</ItemGroup>
<Message Text='[@(i0)][@(i1)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[a2;a1;a3][b1]");
Assert.Equal(3, p.ItemsToBuildWith["i0"].Count);
Assert.Single(p.ItemsToBuildWith["i1"]);
Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count);
p = project.CreateProjectInstance();
Assert.Equal(2, p.ItemsToBuildWith["i0"].Count);
Assert.Single(p.ItemsToBuildWith["i1"]);
Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count);
}
[Fact]
public void RemovesOfPersistedItemsAreReversed3()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='a1'>
<m>m1</m>
</i0>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i0 Include='a1'>
<m>m2</m>
</i0>
<i0 Remove='a1'/>
</ItemGroup>
<Message Text='[%(i0.m)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[]");
Assert.Empty(p.ItemsToBuildWith["i0"]);
Assert.Empty(p.ItemsToBuildWith.ItemTypes);
p = project.CreateProjectInstance();
Assert.Single(p.ItemsToBuildWith["i0"]);
Assert.Equal("m1", p.ItemsToBuildWith["i0"].First().GetMetadataValue("m"));
Assert.Single(p.ItemsToBuildWith.ItemTypes);
}
/// <summary>
/// Persisted item is copied into another item list by an ItemGroup -- the copy
/// should be reversed
/// </summary>
[Fact]
public void RemovesOfPersistedItemsAreReversed4()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='a1'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i0 Include='@(i0)'/>
<i1 Include='@(i0)'/> <!-- for good measure, into another list as well -->
</ItemGroup>
<Message Text='[@(i0)][@(i1)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[a1;a1][a1;a1]");
Assert.Equal(2, p.ItemsToBuildWith["i0"].Count);
Assert.Equal(2, p.ItemsToBuildWith["i1"].Count);
Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count);
p = project.CreateProjectInstance();
Assert.Single(p.ItemsToBuildWith["i0"]);
Assert.Equal("a1", p.ItemsToBuildWith["i0"].First().EvaluatedInclude);
Assert.Empty(p.ItemsToBuildWith["i1"]);
Assert.Single(p.ItemsToBuildWith.ItemTypes);
}
[Fact]
public void RemovesOfItemsOnlyWithMetadataValue()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='a1'>
<m>m1</m>
</i0>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i0 Include='a1'>
<m>m2</m>
</i0>
<i0 Remove='a1' Condition=""'%(i0.m)' == 'm1'""/>
</ItemGroup>
<Message Text='[%(i0.m)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[m2]");
Assert.Single(p.ItemsToBuildWith["i0"]);
}
[Fact]
public void RemoveBatchingOnRemoveValue()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='m1;m2;m3'/>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1 Include='a2'>
<m>m2</m>
</i1>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i0 Remove='%(i1.m)'/>
</ItemGroup>
<Message Text='[@(i0)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[m3]");
Assert.Single(p.ItemsToBuildWith["i0"]);
}
[Fact]
public void RemoveWithWildcards()
{
using (var env = TestEnvironment.Create())
{
var projectDirectory = env.CreateFolder();
env.SetCurrentDirectory(projectDirectory.Path);
var file1 = env.CreateFile(projectDirectory).Path;
var file2 = env.CreateFile(projectDirectory).Path;
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='" + file1 + ";" + file2 + @";other'/>
<i1 Remove='" + projectDirectory.Path + Path.DirectorySeparatorChar + @"*.tmp'/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
Lookup lookup = LookupHelpers.CreateLookup(properties);
ExecuteTask(task, lookup);
Assert.Single(lookup.GetItems("i1"));
Assert.Equal("other", lookup.GetItems("i1").First().EvaluatedInclude);
}
}
[Fact]
public void RemovesNotVisibleToParallelTargetBatches()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='1.in'><output>1.out</output></i>
<i Include='2.in'><output>2.out</output></i>
</ItemGroup>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
<Message Text='start:[@(i)]'/>
<ItemGroup>
<i Remove='1.in;2.in'/>
</ItemGroup>
<Message Text='end:[@(i)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "start:[1.in]", "end:[]", "start:[2.in]", "end:[]" });
}
[Fact]
public void RemovesNotVisibleToParallelTargetBatches2()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='1.in'><output>1.out</output></i>
<i Include='2.in'><output>2.out</output></i>
<j Include='j1'/>
</ItemGroup>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
<Message Text='start:[@(j)]'/>
<ItemGroup>
<j Remove='@(j)'/>
</ItemGroup>
<Message Text='end:[@(j)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "start:[j1]", "end:[]", "start:[j1]", "end:[]" });
}
/// <summary>
/// Whidbey behavior was that items/properties emitted by a target being called, were
/// not visible to subsequent tasks in the calling target. (That was because the project
/// items and properties had been cloned for the target batches.) We must match that behavior.
/// </summary>
[Fact]
public void CalledTargetItemsAreNotVisibleToCallerTarget()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='a'/>
</ItemGroup>
<PropertyGroup>
<p>a</p>
</PropertyGroup>
<Target Name='t3' DependsOnTargets='t' >
<Message Text='after target:[$(p)][@(i)]'/>
</Target>
<Target Name='t' >
<CallTarget Targets='t2'/>
<Message Text='in target:[$(p)][@(i)]'/>
</Target>
<Target Name='t2' >
<CreateItem Include='b'>
<Output TaskParameter='include' ItemName='i'/>
<Output TaskParameter='include' PropertyName='q'/>
</CreateItem>
<ItemGroup>
<i Include='c'/>
</ItemGroup>
<PropertyGroup>
<p>$(p);$(q);c</p>
</PropertyGroup>
</Target>
</Project>
"))));
p.Build(new string[] { "t3" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "in target:[a][a]", "after target:[a;b;c][a;b;c]" });
}
/// <summary>
/// Items and properties should be visible within a CallTarget, even if the CallTargets are separate tasks
/// </summary>
[Fact]
public void CalledTargetItemsAreVisibleWhenTargetsRunFromSeperateTasks()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='Build' DependsOnTargets='t'>
<Message Text='Props During Build:[$(SomeProperty)]'/>
<Message Text='Items During Build:[@(SomeItem)]'/>
</Target>
<Target Name='t'>
<CallTarget Targets='t1'/>
<CallTarget Targets='t2'/>
<Message Text='Props After t1;t2:[$(SomeProperty)]'/>
<Message Text='Items After t1;t2:[@(SomeItem)]'/>
</Target>
<Target Name='t1'>
<PropertyGroup>
<SomeProperty>prop</SomeProperty>
</PropertyGroup>
<ItemGroup>
<SomeItem Include='item'/>
</ItemGroup>
<Message Text='Props During t1:[$(SomeProperty)]'/>
<Message Text='Items During t1:[@(SomeItem)]'/>
</Target>
<Target Name='t2'>
<Message Text='Props During t2:[$(SomeProperty)]'/>
<Message Text='Items During t2:[@(SomeItem)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "Build" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "Props During t1:[prop]", "Props During t2:[prop]", "Props After t1;t2:[]", "Props During Build:[prop]" });
logger.AssertLogContains(new string[] { "Items During t1:[item]", "Items During t2:[item]", "Items After t1;t2:[]", "Items During Build:[item]" });
}
/// <summary>
/// Items and properties should be visible within a CallTarget, even if the targets
/// are Run Separately
/// </summary>
[Fact]
public void CalledTargetItemsAreVisibleWhenTargetsRunSeperately()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='Build' DependsOnTargets='t'>
<Message Text='Props During Build:[$(SomeProperty)]'/>
<Message Text='Items During Build:[@(SomeItem)]'/>
</Target>
<Target Name='t'>
<CallTarget Targets='t1;t2' RunEachTargetSeparately='true'/>
<Message Text='Props After t1;t2:[$(SomeProperty)]'/>
<Message Text='Items After t1;t2:[@(SomeItem)]'/>
</Target>
<Target Name='t1'>
<PropertyGroup>
<SomeProperty>prop</SomeProperty>
</PropertyGroup>
<ItemGroup>
<SomeItem Include='item'/>
</ItemGroup>
<Message Text='Props During t1:[$(SomeProperty)]'/>
<Message Text='Items During t1:[@(SomeItem)]'/>
</Target>
<Target Name='t2'>
<Message Text='Props During t2:[$(SomeProperty)]'/>
<Message Text='Items During t2:[@(SomeItem)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "Build" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "Props During t1:[prop]", "Props During t2:[prop]", "Props After t1;t2:[]", "Props During Build:[prop]" });
logger.AssertLogContains(new string[] { "Items During t1:[item]", "Items During t2:[item]", "Items After t1;t2:[]", "Items During Build:[item]" });
}
/// <summary>
/// Items and properties should be visible within a CallTarget, even if the targets
/// are Run Together
/// </summary>
[Fact]
public void CalledTargetItemsAreVisibleWhenTargetsRunTogether()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='Build' DependsOnTargets='t'>
<Message Text='Props During Build:[$(SomeProperty)]'/>
<Message Text='Items During Build:[@(SomeItem)]'/>
</Target>
<Target Name='t'>
<CallTarget Targets='t1;t2' RunEachTargetSeparately='false'/>
<Message Text='Props After t1;t2:[$(SomeProperty)]'/>
<Message Text='Items After t1;t2:[@(SomeItem)]'/>
</Target>
<Target Name='t1'>
<PropertyGroup>
<SomeProperty>prop</SomeProperty>
</PropertyGroup>
<ItemGroup>
<SomeItem Include='item'/>
</ItemGroup>
<Message Text='Props During t1:[$(SomeProperty)]'/>
<Message Text='Items During t1:[@(SomeItem)]'/>
</Target>
<Target Name='t2'>
<Message Text='Props During t2:[$(SomeProperty)]'/>
<Message Text='Items During t2:[@(SomeItem)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "Build" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "Props During t1:[prop]", "Props During t2:[prop]", "Props After t1;t2:[]", "Props During Build:[prop]" });
logger.AssertLogContains(new string[] { "Items During t1:[item]", "Items During t2:[item]", "Items After t1;t2:[]", "Items During Build:[item]" });
}
/// <summary>
/// Whidbey behavior was that items/properties emitted by a target calling another target, were
/// not visible to the calling target. (That was because the project items and properties had been cloned for the target batches.)
/// We must match that behavior. (For now)
/// </summary>
[Fact]
public void CallerTargetItemsAreNotVisibleToCalledTarget()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='a'/>
</ItemGroup>
<PropertyGroup>
<p>a</p>
</PropertyGroup>
<Target Name='t3' DependsOnTargets='t' >
<Message Text='after target:[$(p)][@(i)]'/>
</Target>
<Target Name='t' >
<CreateItem Include='b'>
<Output TaskParameter='include' ItemName='i'/>
<Output TaskParameter='include' PropertyName='q'/>
</CreateItem>
<ItemGroup>
<i Include='c'/>
</ItemGroup>
<PropertyGroup>
<p>$(p);$(q);c</p>
</PropertyGroup>
<CallTarget Targets='t2'/>
</Target>
<Target Name='t2' >
<Message Text='in target:[$(p)][@(i)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t3" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "in target:[a][a]", "after target:[a;b;c][a;b;c]" });
}
[Fact]
public void ModifyNoOp()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1/>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
Assert.Empty(lookup.GetItems("i1"));
}
[Fact]
public void ModifyItemInTarget()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1>
<m>m2</m>
</i1>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ProjectItemInstance item = lookup.GetItems("i1").First();
Assert.Equal("m2", item.GetMetadataValue("m"));
}
[Fact]
public void ModifyItemInTargetComplex()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<PropertyGroup>
<p1>true</p1>
<p2>v3</p2>
</PropertyGroup>
<ItemGroup>
<i Include='item1'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i>
<m1 Condition=""'$(p1)' == 'true'"">v1</m1>
<m2>v2</m2>
<m3>$(p2)</m3>
</i>
</ItemGroup>
<Message Text='[%(i.identity)|%(i.m1)|%(i.m2)|%(i.m3)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains(@"[item1|v1|v2|v3]");
}
[Fact]
public void ModifyItemInTargetLastMetadataWins()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1>
<m>m2</m>
<m>m3</m>
<m Condition='false'>m4</m>
</i1>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ProjectItemInstance item = lookup.GetItems("i1").First();
Assert.Equal("m3", item.GetMetadataValue("m"));
}
[Fact]
public void ModifyItemEmittedByTask()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<CreateItem Include='a1' AdditionalMetadata='m=m1;n=n1'>
<Output TaskParameter='include' ItemName='i1'/>
</CreateItem>
<ItemGroup>
<i1>
<m>m2</m>
</i1>
</ItemGroup>
<Message Text='[%(i1.m)][%(i1.n)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "[m2][n1]" });
}
[Fact]
public void ModifyItemInTargetWithCondition()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1 Include='a2'>
<m>m2</m>
</i1>
<i1 Condition=""'%(i1.m)'=='m2'"">
<m>m3</m>
</i1>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ProjectItemInstance item1 = lookup.GetItems("i1").First();
ProjectItemInstance item2 = lookup.GetItems("i1").ElementAt(1);
Assert.Equal("a1", item1.EvaluatedInclude);
Assert.Equal("a2", item2.EvaluatedInclude);
Assert.Equal("m1", item1.GetMetadataValue("m"));
Assert.Equal("m3", item2.GetMetadataValue("m"));
}
[Fact]
public void ModifyItemInTargetWithConditionOnMetadata()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1 Include='a2'>
<m>m2</m>
</i1>
<i1>
<m Condition=""'%(i1.m)'=='m2'"">m3</m>
</i1>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ProjectItemInstance item1 = lookup.GetItems("i1").First();
ProjectItemInstance item2 = lookup.GetItems("i1").ElementAt(1);
Assert.Equal("a1", item1.EvaluatedInclude);
Assert.Equal("a2", item2.EvaluatedInclude);
Assert.Equal("m1", item1.GetMetadataValue("m"));
Assert.Equal("m3", item2.GetMetadataValue("m"));
}
[Fact]
public void ModifyItemWithUnqualifiedMetadataError()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'/>
<i1>
<m Condition=""'%(undefined_on_a1)'=='1'"">2</m>
</i1>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
ExecuteTask(task, null);
}
);
}
[Fact]
public void ModifyItemInTargetWithConditionWithoutItemTypeOnMetadataInCondition()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1 Include='a2'>
<m>m2</m>
</i1>
<i1 Condition=""'%(m)'=='m2'"">
<m>m3</m>
</i1>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ProjectItemInstance item1 = lookup.GetItems("i1").First();
ProjectItemInstance item2 = lookup.GetItems("i1").ElementAt(1);
Assert.Equal("a1", item1.EvaluatedInclude);
Assert.Equal("a2", item2.EvaluatedInclude);
Assert.Equal("m1", item1.GetMetadataValue("m"));
Assert.Equal("m3", item2.GetMetadataValue("m"));
}
[Fact]
public void ModifyItemInTargetWithConditionOnMetadataWithoutItemTypeOnMetadataInCondition()
{
string content = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i1 Include='a1'>
<m>m1</m>
</i1>
<i1 Include='a2'>
<m>m2</m>
</i1>
<i1>
<m Condition=""'%(m)'=='m2'"">m3</m>
</i1>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = LookupHelpers.CreateEmptyLookup();
ExecuteTask(task, lookup);
ProjectItemInstance item1 = lookup.GetItems("i1").First();
ProjectItemInstance item2 = lookup.GetItems("i1").ElementAt(1);
Assert.Equal("a1", item1.EvaluatedInclude);
Assert.Equal("a2", item2.EvaluatedInclude);
Assert.Equal("m1", item1.GetMetadataValue("m"));
Assert.Equal("m3", item2.GetMetadataValue("m"));
}
[Fact]
public void ModifyItemOutsideTarget()
{
// <ItemGroup>
// <i0 Include='a1'>
// <m>m1</m>
// <n>n1</n>
// </i0>
// <i0 Include='a2;a3'>
// <m>m2</m>
// <n>n2</n>
// </i0>
// <i0 Include='a4'>
// <m>m3</m>
// <n>n3</n>
// </i0>
// </ItemGroup>
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i0>
<m>m4</m>
</i0>
</ItemGroup>
</Target></Project>");
IntrinsicTask task = CreateIntrinsicTask(content);
Lookup lookup = GenerateLookup(task.Project);
task.ExecuteTask(lookup);
ICollection<ProjectItemInstance> i0Group = lookup.GetItems("i0");
Assert.Equal(4, i0Group.Count);
foreach (ProjectItemInstance item in i0Group)
{
Assert.Equal("m4", item.GetMetadataValue("m"));
}
}
[Fact]
public void RemoveComplexMidlExample()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<PropertyGroup>
<UseIdlBasedDllData>true</UseIdlBasedDllData>
<MidlDllDataFileName>dlldata.c</MidlDllDataFileName>
<MidlDllDataDir>dlldatadir</MidlDllDataDir>
<MidlHeaderDir>headerdir</MidlHeaderDir>
<MidlTlbDir>tlbdir</MidlTlbDir>
<MidlProxyDir>proxydir</MidlProxyDir>
<MidlInterfaceDir>interfacedir</MidlInterfaceDir>
</PropertyGroup>
<ItemGroup>
<Idl Include='a.idl'/>
<Idl Include='b.idl'>
<DllDataFileName>mydlldata.c</DllDataFileName>
</Idl>
<Idl Include='c.idl'>
<HeaderFileName>myheader.h</HeaderFileName>
</Idl>
</ItemGroup>
<Target Name='MIDL'>
<Message Text='Before: [%(idl.identity)|%(Idl.m1)]'/>
<ItemGroup>
<Idl>
<DllDataFileName Condition=""'$(UseIdlBasedDllData)' == 'true' and '%(Idl.DllDataFileName)' == ''"">$(MidlDllDataDir)\%(Filename)_dlldata.c</DllDataFileName>
<DllDataFileName Condition=""'$(UseIdlBasedDllData)' != 'true' and '%(Idl.DllDataFileName)' == ''"">$(MidlDllDataFileName)</DllDataFileName>
<HeaderFileName Condition=""'%(Idl.HeaderFileName)' == ''"">$(MidlHeaderDir)\%(Idl.Filename).h</HeaderFileName>
<TypeLibraryName Condition=""'%(Idl.TypeLibraryName)' == ''"">$(MidlTlbDir)\%(Filename).tlb</TypeLibraryName>
<ProxyFileName Condition=""'%(Idl.ProxyFileName)' == ''"">$(MidlProxyDir)\%(Filename)_p.c</ProxyFileName>
<InterfaceIdentifierFileName Condition=""'%(Idl.InterfaceIdentifierFileName)' == ''"">$(MidlInterfaceDir)\%(Filename)_i.c</InterfaceIdentifierFileName>
</Idl>
</ItemGroup>
<Message Text='[%(idl.identity)|%(idl.dlldatafilename)|%(idl.headerfilename)|%(idl.TypeLibraryName)|%(idl.ProxyFileName)|%(idl.InterfaceIdentifierFileName)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "MIDL" }, new ILogger[] { logger });
logger.AssertLogContains(@"[a.idl|" + Path.Combine("dlldatadir", "a_dlldata.c") + "|" + Path.Combine("headerdir", "a.h") + "|" + Path.Combine("tlbdir", "a.tlb")
+ "|" + Path.Combine("proxydir", "a_p.c") + "|" + Path.Combine("interfacedir", "a_i.c") + "]",
@"[b.idl|mydlldata.c|" + Path.Combine("headerdir", "b.h") + "|" + Path.Combine("tlbdir", "b.tlb") + "|" + Path.Combine("proxydir", "b_p.c")
+ "|" + Path.Combine("interfacedir", "b_i.c") + "]",
@"[c.idl|" + Path.Combine("dlldatadir", "c_dlldata.c") + "|myheader.h|" + Path.Combine("tlbdir", "c.tlb") + "|" + Path.Combine("proxydir", "c_p.c")
+ "|" + Path.Combine("interfacedir", "c_i.c") + "]");
}
[Fact]
public void ModifiesOfPersistedItemsAreReversed1()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='i1'>
<m>m0</m>
</i0>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i0>
<m>m1</m>
</i0>
</ItemGroup>
</Target>
<Target Name='t2'>
<Message Text='[%(i0.m)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t", "t2" }, new ILogger[] { logger });
logger.AssertLogContains("[m1]");
ProjectItemInstance item = p.ItemsToBuildWith["i0"].First();
Assert.Equal("m1", item.GetMetadataValue("m"));
p = project.CreateProjectInstance();
item = p.ItemsToBuildWith["i0"].First();
Assert.Equal("m0", item.GetMetadataValue("m"));
}
/// <summary>
/// Modify of an item copied during the build
/// </summary>
[Fact]
public void ModifiesOfPersistedItemsAreReversed2()
{
MockLogger logger = new MockLogger();
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i0 Include='i1'>
<m>m0</m>
<n>n0</n>
</i0>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i1 Include='@(i0)'>
<m>m1</m>
</i1>
<i1>
<n>n1</n>
</i1>
</ItemGroup>
</Target>
<Target Name='t2'>
<Message Text='[%(i0.m)][%(i0.n)]'/>
<Message Text='[%(i1.m)][%(i1.n)]'/>
</Target>
</Project>
"))));
ProjectInstance p = project.CreateProjectInstance();
p.Build(new string[] { "t", "t2" }, new ILogger[] { logger });
logger.AssertLogContains("[m0][n0]", "[m1][n1]");
Assert.Single(p.ItemsToBuildWith["i0"]);
Assert.Single(p.ItemsToBuildWith["i1"]);
Assert.Equal("m0", p.ItemsToBuildWith["i0"].First().GetMetadataValue("m"));
Assert.Equal("n0", p.ItemsToBuildWith["i0"].First().GetMetadataValue("n"));
Assert.Equal("m1", p.ItemsToBuildWith["i1"].First().GetMetadataValue("m"));
Assert.Equal("n1", p.ItemsToBuildWith["i1"].First().GetMetadataValue("n"));
p = project.CreateProjectInstance();
Assert.Single(p.ItemsToBuildWith["i0"]);
Assert.Empty(p.ItemsToBuildWith["i1"]);
Assert.Equal("m0", p.ItemsToBuildWith["i0"].First().GetMetadataValue("m"));
Assert.Equal("n0", p.ItemsToBuildWith["i0"].First().GetMetadataValue("n"));
}
/// <summary>
/// The case is where a transform is done on an item to generate a pdb file name when the extension of an item is dll
/// the resulting items is expected to have an extension metadata of pdb but instead has an extension of dll
/// </summary>
[Fact]
public void IncludeCheckOnMetadata()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project xmlns='msbuildnamespace'>
<Target Name='a'>
<ItemGroup>
<Content Include='a.dll' />
<Content Include=""@(Content->'%(FileName).pdb')"" Condition=""'%(Content.Extension)' == '.dll'""/>
</ItemGroup>
<Message Text='[%(Content.Identity)]->[%(Content.Extension)]' Importance='High'/>
</Target>
</Project> "))));
bool success = p.Build(new string[] { "a" }, new ILogger[] { logger });
Assert.True(success);
logger.AssertLogContains("[a.dll]->[.dll]");
logger.AssertLogContains("[a.pdb]->[.pdb]");
}
/// <summary>
/// The case is where a transform is done on an item to generate a pdb file name the batching is done on the identity.
/// If the identity was also copied over then we would only get one bucket instead of two buckets
/// </summary>
[Fact]
public void IncludeCheckOnMetadata2()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project xmlns='msbuildnamespace'>
<Target Name='a'>
<ItemGroup>
<Content Include='a.dll' />
<Content Include=""@(Content->'%(FileName)%(Extension).pdb')""/>
<Content Include=""@(Content->'%(FileName)%(Extension).pdb')"" Condition=""'%(Content.Identity)' != ''""/>
</ItemGroup>
<Message Text='[%(Content.Identity)]->[%(Content.Extension)]' Importance='High'/>
</Target>
</Project> "))));
bool success = p.Build(new string[] { "a" }, new ILogger[] { logger });
Assert.True(success);
logger.AssertLogContains("[a.dll]->[.dll]");
logger.AssertLogContains("[a.dll.pdb]->[.pdb]");
logger.AssertLogContains("[a.dll.pdb.pdb]->[.pdb]");
}
/// <summary>
/// Make sure that recursive dir still gets the right file
///
/// </summary>
[Fact]
[Trait("Category", "netcore-osx-failing")]
[Trait("Category", "netcore-linux-failing")]
[Trait("Category", "mono-osx-failing")]
public void IncludeCheckOnMetadata_3()
{
MockLogger logger = new MockLogger();
string tempPath = Path.GetTempPath();
string directoryForTest = Path.Combine(tempPath, "IncludeCheckOnMetadata_3\\Test");
string fileForTest = Path.Combine(directoryForTest, "a.dll");
try
{
if (Directory.Exists(directoryForTest))
{
FileUtilities.DeleteWithoutTrailingBackslash(directoryForTest, true);
}
else
{
Directory.CreateDirectory(directoryForTest);
}
File.WriteAllText(fileForTest, fileForTest);
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project xmlns='msbuildnamespace'>
<Target Name='a'>
<ItemGroup>
<Content Include='a.dll' />
<Content Include='" + Path.Combine(directoryForTest, "..", "**") + @"' Condition=""'%(Content.Extension)' == '.dll'""/>
</ItemGroup>
<Message Text='[%(Content.Identity)]->[%(Content.Extension)]->[%(Content.RecursiveDir)]' Importance='High'/>
</Target>
</Project> "))));
bool success = p.Build(new string[] { "a" }, new ILogger[] { logger });
Assert.True(success);
logger.AssertLogContains("[a.dll]->[.dll]->[]");
logger.AssertLogContains(
"[" + Path.Combine(directoryForTest, "..", "Test", "a.dll") + @"]->[.dll]->[Test"
+ Path.DirectorySeparatorChar + "]");
}
finally
{
if (Directory.Exists(directoryForTest))
{
FileUtilities.DeleteWithoutTrailingBackslash(directoryForTest, true);
}
}
}
[Fact]
public void RemoveItemInImportedFile()
{
MockLogger logger = new MockLogger();
string importedFile = null;
try
{
importedFile = FileUtilities.GetTemporaryFile();
File.WriteAllText(importedFile, ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i1 Include='imported'/>
</ItemGroup>
</Project>
"));
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Import Project='" + importedFile + @"'/>
<Target Name='t'>
<Message Text='[@(i1)]'/>
<ItemGroup>
<i1 Remove='imported'/>
</ItemGroup>
<Message Text='[@(i1)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[imported]", "[]");
}
finally
{
ObjectModelHelpers.DeleteTempFiles(new string[] { importedFile });
}
}
[Fact]
public void ModifyItemInImportedFile()
{
MockLogger logger = new MockLogger();
string importedFile = null;
try
{
importedFile = FileUtilities.GetTemporaryFile();
File.WriteAllText(importedFile, ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i1 Include='imported'/>
</ItemGroup>
</Project>
"));
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Import Project='" + importedFile + @"'/>
<Target Name='t'>
<ItemGroup>
<i1>
<m>m1</m>
</i1>
</ItemGroup>
<Message Text='[%(i1.m)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[m1]");
}
finally
{
ObjectModelHelpers.DeleteTempFiles(new string[] { importedFile });
}
}
/// <summary>
/// Properties produced in one target batch are not visible to another
/// </summary>
[Fact]
public void OutputPropertiesInTargetBatchesCreateItem()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<!-- just to cause two target batches -->
<i Include='1.in'><output>1.out</output></i>
<i Include='2.in'><output>2.out</output></i>
</ItemGroup>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
<Message Text='start:[$(p)]'/>
<CreateProperty Value='$(p)--%(i.Identity)'>
<Output TaskParameter='Value' PropertyName='p'/>
</CreateProperty>
<Message Text='end:[$(p)]'/>
</Target>
<Target Name='t2'>
<Message Text='final:[$(p)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t", "t2" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "start:[]", "end:[--1.in]", "start:[]", "end:[--2.in]", "final:[--2.in]" });
}
/// <summary>
/// Properties produced in one task batch are not visible to another
/// </summary>
[Fact]
public void OutputPropertiesInTaskBatchesCreateItem()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<i Include='1.in;2.in'/>
</ItemGroup>
<CreateProperty Value='$(p)--%(i.Identity)'>
<Output TaskParameter='Value' PropertyName='p'/>
</CreateProperty>
<Message Text='end:[$(p)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains(new string[] { "end:[--2.in]" });
}
/// <summary>
/// In this case gen.cpp was getting ObjectFile of def.obj.
/// </summary>
[Fact]
public void PhoenixBatchingIssue()
{
ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<CppCompile Include='gen.cpp'/>
<CppCompile Include='def.cpp'>
<ObjectFile>def.obj</ObjectFile>
</CppCompile>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<CppCompile>
<IncludeInLib Condition=""'%(CppCompile.IncludeInLib)' == ''"">true</IncludeInLib>
</CppCompile>
<CppCompile>
<ObjectFile>%(Filename).obj</ObjectFile>
</CppCompile>
</ItemGroup>
</Target>
</Project>
"))));
ProjectInstance instance = new ProjectInstance(xml);
instance.Build();
Assert.Equal(2, instance.Items.Count());
Assert.Equal("gen.obj", instance.GetItems("CppCompile").First().GetMetadataValue("ObjectFile"));
Assert.Equal("def.obj", instance.GetItems("CppCompile").Last().GetMetadataValue("ObjectFile"));
}
[Fact]
public void PropertiesInInferredBuildCreateProperty()
{
string[] files = null;
try
{
files = ObjectModelHelpers.GetTempFiles(2, new DateTime(2005, 1, 1));
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<i Include='" + files.First() + "'><output>" + files.ElementAt(1) + @"</output></i>
</ItemGroup>
<Target Name='t2' DependsOnTargets='t'>
<Message Text='final:[$(p)]'/>
</Target>
<Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.Output)'>
<Message Text='start:[$(p)]'/>
<CreateProperty Value='@(i)'>
<Output TaskParameter='Value' PropertyName='p'/>
</CreateProperty>
<Message Text='end:[$(p)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t2" }, new ILogger[] { logger });
// We should only see messages from the second target, as the first is only inferred
logger.AssertLogDoesntContain("start:");
logger.AssertLogDoesntContain("end:");
logger.AssertLogContains(new string[] { "final:[" + files.First() + "]" });
}
finally
{
ObjectModelHelpers.DeleteTempFiles(files);
}
}
[Fact]
public void ModifyItemPreviouslyModified()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<x Include='a'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<x>
<m1>1</m1>
</x>
<x>
<m1>2</m1>
</x>
</ItemGroup>
<Message Text='[%(x.m1)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogDoesntContain("[1]");
logger.AssertLogContains("[2]");
}
[Fact]
public void ModifyItemPreviouslyModified2()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<x Include='a'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<x>
<m1>1</m1>
</x>
</ItemGroup>
<ItemGroup>
<x>
<m1>2</m1>
</x>
</ItemGroup>
<Message Text='[%(x.m1)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogDoesntContain("[1]");
logger.AssertLogContains("[2]");
}
[Fact]
public void RemoveItemPreviouslyModified()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<x Include='a'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<x>
<m1>1</m1>
</x>
<x Remove='@(x)'/>
</ItemGroup>
<Message Text='[%(x.m1)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogDoesntContain("[1]");
logger.AssertLogDoesntContain("[2]");
}
[Fact]
public void RemoveItemPreviouslyModified2()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<x Include='a'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<x>
<m1>1</m1>
</x>
</ItemGroup>
<ItemGroup>
<x Remove='@(x)'/>
</ItemGroup>
<Message Text='[%(x.m1)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogDoesntContain("[1]");
logger.AssertLogDoesntContain("[2]");
}
[Fact]
public void FilterItemPreviouslyModified()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<x Include='a'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<x>
<m1>1</m1>
</x>
<x Condition=""'%(x.m1)'=='1'"">
<m1>2</m1>
</x>
</ItemGroup>
<Message Text='[%(x.m1)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogDoesntContain("[1]");
logger.AssertLogContains("[2]");
}
[Fact]
public void FilterItemPreviouslyModified2()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<x Include='a'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<x>
<m1>1</m1>
</x>
<x>
<m1 Condition=""'%(x.m1)'=='1'"">2</m1>
</x>
</ItemGroup>
<Message Text='[%(x.m1)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogDoesntContain("[1]");
logger.AssertLogContains("[2]");
}
[Fact]
public void FilterItemPreviouslyModified3()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<A Include='a;b;c'>
<m>m1</m>
</A>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<A Condition=""'%(m)' == 'm1'"">
<m>m2</m>
</A>
</ItemGroup>
<ItemGroup>
<A Condition=""'%(m)' == 'm2'"">
<m>m3</m>
</A>
</ItemGroup>
<ItemGroup>
<A Condition=""'%(m)' == 'm3'"">
<m>m4</m>
</A>
</ItemGroup>
<Message Text='[@(A) = %(A.m)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[a;b;c = m4]");
}
[Fact]
public void FilterItemPreviouslyModified4()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<A Include='a;b;c'>
<m>m1</m>
</A>
<A Condition=""'%(Identity)' == 'a' or '%(Identity)' == 'c'"">
<m>m2</m>
</A>
<A Condition=""'%(Identity)' == 'a' or '%(Identity)' == 'c'"">
<m>m3</m>
</A>
</ItemGroup>
<Message Text='[@(A) = %(A.m)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[b = m1]");
logger.AssertLogContains("[a;c = m3]");
}
[Fact]
public void FilterItemPreviouslyModified5()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='t'>
<ItemGroup>
<A Include='a;b;c'>
<m>m1</m>
</A>
<A Condition=""'%(Identity)' == 'a' or '%(Identity)' == 'c'"">
<m>m2</m>
</A>
<A Condition=""'%(Identity)' == 'a'"">
<m>m3</m>
</A>
</ItemGroup>
<Message Text='[@(A) = %(A.m)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[a = m3]");
logger.AssertLogContains("[b = m1]");
logger.AssertLogContains("[c = m2]");
}
[Fact]
public void FilterItemPreviouslyModified6()
{
MockLogger logger = new MockLogger();
Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<A Include='a;b;c'>
<m>m1</m>
</A>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<A Condition=""'%(m)' == 'm1'"">
<m>m2</m>
</A>
</ItemGroup>
<ItemGroup>
<A Condition=""'%(m)' == 'm2'"">
<m></m>
</A>
</ItemGroup>
<ItemGroup>
<A Condition=""'%(m)' == 'm3'"">
<m>m3</m>
</A>
</ItemGroup>
<Message Text='[@(A)=%(A.m)]'/>
</Target>
</Project>
"))));
p.Build(new string[] { "t" }, new ILogger[] { logger });
logger.AssertLogContains("[a;b;c=]");
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
#region Helpers
private static PropertyDictionary<ProjectPropertyInstance> GeneratePropertyGroup()
{
PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
properties.Set(ProjectPropertyInstance.Create("p0", "v0"));
return properties;
}
private static Lookup GenerateLookupWithItemsAndProperties(ProjectInstance project)
{
PropertyDictionary<ProjectPropertyInstance> pg = new PropertyDictionary<ProjectPropertyInstance>();
pg.Set(ProjectPropertyInstance.Create("p0", "v0"));
Lookup lookup = GenerateLookup(project, pg);
return lookup;
}
private static Lookup GenerateLookup(ProjectInstance project)
{
return GenerateLookup(project, new PropertyDictionary<ProjectPropertyInstance>());
}
private static Lookup GenerateLookup(ProjectInstance project, PropertyDictionary<ProjectPropertyInstance> properties)
{
List<ProjectItemInstance> items = new List<ProjectItemInstance>();
ProjectItemInstance item1 = new ProjectItemInstance(project, "i0", "a1", project.FullPath);
ProjectItemInstance item2 = new ProjectItemInstance(project, "i0", "a2", project.FullPath);
ProjectItemInstance item3 = new ProjectItemInstance(project, "i0", "a3", project.FullPath);
ProjectItemInstance item4 = new ProjectItemInstance(project, "i0", "a4", project.FullPath);
item1.SetMetadata("m", "m1");
item1.SetMetadata("n", "n1");
item2.SetMetadata("m", "m2");
item2.SetMetadata("n", "n2");
item3.SetMetadata("m", "m2");
item3.SetMetadata("n", "n2");
item4.SetMetadata("m", "m3");
item4.SetMetadata("n", "n3");
items.Add(item1);
items.Add(item2);
items.Add(item3);
items.Add(item4);
ItemDictionary<ProjectItemInstance> itemsByName = new ItemDictionary<ProjectItemInstance>();
itemsByName.ImportItems(items);
Lookup lookup = LookupHelpers.CreateLookup(properties, itemsByName);
return lookup;
}
private static IntrinsicTask CreateIntrinsicTask(string content)
{
Project project = new Project(XmlReader.Create(new StringReader(content)));
ProjectInstance projectInstance = project.CreateProjectInstance();
ProjectTargetInstanceChild targetChild = projectInstance.Targets["t"].Children.First();
NodeLoggingContext nodeContext = new NodeLoggingContext(new MockLoggingService(), 1, false);
BuildRequestEntry entry = new BuildRequestEntry(new BuildRequest(1 /* submissionId */, 0, 1, new string[] { "t" }, null, BuildEventContext.Invalid, null), new BuildRequestConfiguration(1, new BuildRequestData("projectFile", new Dictionary<string, string>(), "3.5", new string[0], null), "2.0"));
entry.RequestConfiguration.Project = projectInstance;
IntrinsicTask task = IntrinsicTask.InstantiateTask(
targetChild,
nodeContext.LogProjectStarted(entry).LogTargetBatchStarted(projectInstance.FullPath, projectInstance.Targets["t"], null, TargetBuiltReason.None),
projectInstance,
false);
return task;
}
private void ExecuteTask(IntrinsicTask task)
{
ExecuteTask(task, null);
}
private void ExecuteTask(IntrinsicTask task, Lookup lookup)
{
if (lookup == null)
{
lookup = LookupHelpers.CreateEmptyLookup();
}
task.ExecuteTask(lookup);
}
internal static void AssertItemEvaluationFromTarget(string projectContents, string targetName, string itemType, string[] inputFiles, string[] expectedInclude, bool makeExpectedIncludeAbsolute = false, Dictionary<string, string>[] expectedMetadataPerItem = null, bool normalizeSlashes = false)
{
ObjectModelHelpers.AssertItemEvaluationFromGenericItemEvaluator((p, c) =>
{
var project = new Project(p, new Dictionary<string, string>(), MSBuildConstants.CurrentToolsVersion, c);
var projectInstance = project.CreateProjectInstance();
var targetChild = projectInstance.Targets["t"].Children.First();
var nodeContext = new NodeLoggingContext(new MockLoggingService(), 1, false);
var entry = new BuildRequestEntry(new BuildRequest(1 /* submissionId */, 0, 1, new string[] { targetName }, null, BuildEventContext.Invalid, null), new BuildRequestConfiguration(1, new BuildRequestData("projectFile", new Dictionary<string, string>(), "3.5", new string[0], null), "2.0"));
entry.RequestConfiguration.Project = projectInstance;
var task = IntrinsicTask.InstantiateTask(
targetChild,
nodeContext.LogProjectStarted(entry).LogTargetBatchStarted(projectInstance.FullPath, projectInstance.Targets["t"], null, TargetBuiltReason.None),
projectInstance,
false);
var lookup = new Lookup(new ItemDictionary<ProjectItemInstance>(), new PropertyDictionary<ProjectPropertyInstance>());
task.ExecuteTask(lookup);
return lookup.GetItems(itemType).Select(i => (ObjectModelHelpers.TestItem)new ObjectModelHelpers.ProjectItemInstanceTestItemAdapter(i)).ToList();
},
projectContents,
inputFiles,
expectedInclude,
makeExpectedIncludeAbsolute,
expectedMetadataPerItem,
normalizeSlashes);
}
#endregion
}
}
| 41.583077 | 308 | 0.500715 | [
"MIT"
] | Sejsel/msbuild | src/Build.UnitTests/BackEnd/IntrinsicTask_Tests.cs | 148,909 | C# |
// Copyright (c) Stickymaddness All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using Sextant.Domain;
using System.Collections.Generic;
namespace Sextant.Tests
{
public class TestCommunicator : ICommunicator
{
public List<string> MessagesCommunicated { get; } = new List<string>();
public void Communicate(string message)
{
MessagesCommunicated.Add(message);
}
public void Initialize()
{ }
public void StopComminicating()
{ }
}
}
| 24.36 | 111 | 0.656814 | [
"Apache-2.0"
] | RikCSherman/R2R-VoiceAttack | Sextant.Tests/TestCommunicator.cs | 611 | C# |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.