/// <summary>
/// The get insured persons by keys.
/// </summary>
/// <param name="keys">
/// The keys.
/// </param>
/// <returns>
/// The
/// <see>
/// <cref>IList</cref>
/// </see>
/// .
/// </returns>
public IList <InsuredPerson> GetInsuredPersonsByKeys(IEnumerable <SearchKey> keys)
{
var session = ObjectFactory.GetInstance <ISessionFactory>().GetCurrentSession();
var insuredPersonManager = ObjectFactory.GetInstance <IInsuredPersonManager>();
IList <InsuredPerson> insuredPersons = new List <InsuredPerson>();
var searchKeys = keys as IList <SearchKey> ?? keys.ToList();
var keysInserting = searchKeys.Where(x => x.KeyType.Insertion);
// поиск по ключам
if (searchKeys.Any())
{
SearchKeyType kt = null;
var query =
session.QueryOver <SearchKey>()
.JoinAlias(x => x.KeyType, () => kt)
.Where(x => kt.Insertion)
.WhereRestrictionOn(x => x.KeyValue)
.IsIn(keysInserting.Select(y => y.KeyValue).ToList())
.OrderBy(x => kt.Weight)
.Asc.SelectList(x => x.SelectGroup(y => y.InsuredPerson.Id).SelectGroup(y => kt.Weight))
.List <object[]>();
insuredPersons =
query.GroupBy(x => x[0]).Select(x => insuredPersonManager.GetById((Guid)x.Key)).Where(x => x != null).ToList();
}
return(insuredPersons);
}
/// <summary>
/// The btn save_ click.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// The e.
/// </param>
protected void btnSave_Click(object sender, EventArgs e)
{
// Валидация
Page.Validate();
if (!Page.IsValid)
{
return;
}
// либо новый объект либо поднимаем редактируемый из БД
var keyType = new SearchKeyType();
if (Request.QueryString["SearchKeyTypeId"] != null)
{
keyType = tfomsService.GetSearchKeyType(Guid.Parse(Request.QueryString["SearchKeyTypeId"]));
}
// заполняем объекта данными из формы
MoveDataFromGUI2Object(keyType);
// сохраняем объект в БД
tfomsService.SaveSearchKeyType(keyType);
// переход на родительскую страницу
Response.Redirect("~/Pages/Twins/SearchKeyTypes.aspx");
}
/// <summary>
/// Сохраняет ключ поиска в БД
/// </summary>
/// <param name="keyType">
/// The key Type.
/// </param>
/// <returns>
/// The <see cref="Guid"/>.
/// </returns>
public Guid SaveSearchKeyType(SearchKeyType keyType)
{
// Назначаем ТФОМС текущего пользователя
var currentUser = ObjectFactory.GetInstance <ISecurityProvider>().GetCurrentUser();
if (currentUser != null && currentUser.HasTf())
{
keyType.Tfoms = currentUser.GetTf();
}
if (!EqualsBd(keyType))
{
keyType.Recalculated = false;
CalculateKeysPool.Instance.AddJobForUserKey(keyType);
}
// Ключ активный
keyType.IsActive = true;
// Сохранение в БД
var session = ObjectFactory.GetInstance <ISessionFactory>().GetCurrentSession();
session.SaveOrUpdate(keyType);
session.Flush();
return(keyType.Id);
}
/// <summary>
/// Расчитывает ключ для указанных параметров
/// </summary>
/// <param name="searchKeyTypeXml">
/// </param>
/// <param name="insuredPersonDataXml">
/// </param>
/// <param name="documentXml">
/// </param>
/// <param name="address1Xml">
/// </param>
/// <param name="address2Xml">
/// </param>
/// <param name="medicalInsuranceXml">
/// </param>
/// <param name="okato">
/// </param>
/// <returns>
/// The <see cref="byte[]"/>.
/// </returns>
public byte[] CalculateUserSearchKey(
string searchKeyTypeXml,
string insuredPersonDataXml,
string documentXml,
string address1Xml,
string address2Xml,
string medicalInsuranceXml,
string okato)
{
// Парсинг
ModelAdapter model = null;
try
{
model = new ModelAdapter
{
SearchKeyType = SearchKeyType.FromXML(searchKeyTypeXml),
PersonData = InsuredPersonDatum.FromXML(insuredPersonDataXml),
Document = Document.FromXML(documentXml),
Address1 = address.FromXML(address1Xml),
Address2 = address.FromXML(address2Xml),
MedicalInsurance = MedicalInsurance.FromXML(medicalInsuranceXml),
Okato = okato
};
}
catch (Exception ex)
{
throw new Exception("Ошибка парсинга xml", ex);
}
return(CalculateUserSearchKey(model));
}
/// <summary>
/// Расчитывает ключ для указанных параметров
/// </summary>
/// <param name="searchKeyTypeXml">
/// </param>
/// <param name="exchangeXml">
/// The exchange Xml.
/// </param>
/// <param name="documentXml">
/// The document Xml.
/// </param>
/// <param name="addressXml">
/// The address Xml.
/// </param>
/// <returns>
/// The <see cref="byte[]"/>.
/// </returns>
public byte[] CalculateUserSearchKeyExchange(
string searchKeyTypeXml,
string exchangeXml,
string documentXml,
string addressXml)
{
// Парсинг
ModelAdapter model = null;
try
{
model = new ModelAdapter
{
SearchKeyType = SearchKeyType.FromXML(searchKeyTypeXml),
PersonData = InsuredPersonDatum.FromXML(exchangeXml),
Document = Document.FromXML(documentXml),
Address1 = address.FromXML(addressXml)
};
}
catch (Exception ex)
{
throw new Exception("Ошибка парсинга xml", ex);
}
// создание внешнего hash алгоритма
var hashAlgorithm = new HashAlgorithm();
byte[] hash = null;
using (var stream = new MemoryStream())
{
using (var currentWriter = new BinaryWriter(stream, Encoding.Unicode))
{
// Персональные данные
WriteField(model, x => x.PersonData.LastName, currentWriter);
WriteField(model, x => x.PersonData.FirstName, currentWriter);
WriteField(model, x => x.PersonData.MiddleName, currentWriter);
WriteField(model, x => x.PersonData.Birthday, currentWriter);
WriteField(model, x => x.PersonData.Birthplace, currentWriter);
WriteField(model, x => x.PersonData.Snils, currentWriter);
// Документ УДЛ
WriteField(model, x => x.Document.DocumentTypeId, currentWriter);
WriteField(model, x => x.Document.Series, currentWriter);
WriteField(model, x => x.Document.Number, currentWriter);
// расчет ключа с помощью внешнего алгоритма
stream.Flush();
stream.Position = 0;
hash = hashAlgorithm.ComputeHash(stream);
}
}
return(hash);
}
public static QueryResponseItemize CreateNew(int depth = 0)
{
rt.srz.model.srz.QueryResponseItemize entity = new rt.srz.model.srz.QueryResponseItemize();
// You may need to maually enter this key if there is a constraint violation.
entity.Id = System.Guid.NewGuid();
using (rt.srz.business.manager.IQueryResponseManager queryResponseManager = ObjectFactory.GetInstance <IQueryResponseManager>())
{
var all = queryResponseManager.GetAll(1);
QueryResponse entityRef = null;
if (all.Count > 0)
{
entityRef = all[0];
}
if (entityRef == null && depth < 3)
{
depth++;
entityRef = QueryResponseTests.CreateNew(depth);
ObjectFactory.GetInstance <ISessionFactory>().GetCurrentSession().Save(entityRef);
}
entity.QueryResponse = entityRef;
}
using (rt.srz.business.manager.ISearchKeyTypeManager searchKeyTypeManager = ObjectFactory.GetInstance <ISearchKeyTypeManager>())
{
var all = searchKeyTypeManager.GetAll(1);
SearchKeyType entityRef = null;
if (all.Count > 0)
{
entityRef = all[0];
}
if (entityRef == null && depth < 3)
{
depth++;
entityRef = SearchKeyTypeTests.CreateNew(depth);
ObjectFactory.GetInstance <ISessionFactory>().GetCurrentSession().Save(entityRef);
}
entity.KeyType = entityRef;
}
return(entity);
}
/// <summary>
/// Расчитывает ключ для указанных параметров
/// </summary>
/// <param name="keyType">
/// </param>
/// <param name="personData">
/// </param>
/// <param name="document">
/// </param>
/// <param name="address1">
/// </param>
/// <param name="address2">
/// </param>
/// <param name="medicalInsurance">
/// </param>
/// <param name="okato">
/// </param>
/// <returns>
/// The <see cref="byte[]"/>.
/// </returns>
public byte[] CalculateUserSearchKey(
SearchKeyType keyType,
InsuredPersonDatum personData,
Document document,
address address1,
address address2,
MedicalInsurance medicalInsurance,
string okato)
{
var model = new ModelAdapter
{
SearchKeyType = keyType,
PersonData = personData,
Document = document,
Address1 = address1,
Address2 = address2,
MedicalInsurance = medicalInsurance,
Okato = okato
};
return(CalculateUserSearchKey(model));
}
/// <summary>
/// Добавляет в очередь расчет пользователького ключа
/// </summary>
/// <param name="keyType">
/// The key Type.
/// </param>
public void AddJobForUserKey(SearchKeyType keyType)
{
// Получаем фабрику
var schedulerFactory = ObjectFactory.TryGetInstance <ISchedulerFactory>();
if (schedulerFactory == null)
{
return;
}
// Получаем шедулер
var scheduler = schedulerFactory.AllSchedulers.FirstOrDefault();
if (scheduler == null)
{
return;
}
// Считаем сколько надо посчитать ключей
var session = ObjectFactory.GetInstance <ISessionFactory>().GetCurrentSession();
var count = session.QueryOver <Statement>().RowCount();
var countJob = (count / CountInJob) + 1;
lock (LockObject)
{
// Ставим на паузу тригер пересчета ключей
var key = ObjectFactory.GetInstance <IQuartzInfoProvider>()
.GetTriggerKey(JobGroupNames.Service, JobNames.CalculatingKeys);
if (key != null)
{
scheduler.PauseTrigger(key);
}
try
{
// очищаем очередь задач на расчет ключей этого типа
var list = instance.Queue.Where(x => x.SearchKeyType.Id != keyType.Id).ToList();
instance.Queue.Clear();
foreach (var calculateJobInfo in list)
{
instance.Queue.Enqueue(calculateJobInfo);
}
// останавливаем все работы, выполняемые для указанного ключа
var executingJobs = scheduler.GetCurrentlyExecutingJobs();
foreach (var executionContext in
executingJobs.Where(
x =>
x.JobDetail.JobDataMap.Contains(
new KeyValuePair <string, object>(
"Имя ключа",
keyType.Code))))
{
scheduler.Interrupt(executionContext.FireInstanceId);
}
for (var i = 0; i < countJob; i++)
{
var jobInfo = new CalculateKeysJobInfo
{
IsStandard = false,
From = (i * CountInJob) + 1,
To = (i + 1) * CountInJob,
SearchKeyType = keyType,
IsDeleted = false
};
instance.Queue.Enqueue(jobInfo);
}
}
finally
{
scheduler.ResumeTrigger(key);
}
}
}
/// <summary>
/// Сохраняет ключ поиска
/// </summary>
/// <param name="keyType">
/// The key Type.
/// </param>
/// <returns>
/// The <see cref="Guid"/> .
/// </returns>
public Guid SaveSearchKeyType(SearchKeyType keyType)
{
return(InvokeInterceptors(() => Service.SaveSearchKeyType(keyType)));
}
/// <summary>
/// The move data from object 2 gui.
/// </summary>
/// <param name="searchKeyType">
/// The search key type.
/// </param>
private void MoveDataFromObject2GUI(SearchKeyType searchKeyType)
{
// Имя ключа
tbKeyName.Text = searchKeyType.Name;
// Код ключа
tbKeyCode.Text = searchKeyType.Code;
// Тип операции
if (searchKeyType.OperationKey != null)
{
ddlOperationKey.SelectedValue = searchKeyType.OperationKey.Id.ToString();
}
// Фамилия
chbUseLastName.Checked = searchKeyType.LastName;
if (chbUseLastName.Checked)
{
tbLastNameLength.Enabled = true;
tbLastNameLength.Text = searchKeyType.LastNameLength.ToString();
}
// Имя
chbUseFirstName.Checked = searchKeyType.FirstName;
if (chbUseFirstName.Checked)
{
tbFirstNameLength.Enabled = true;
tbFirstNameLength.Text = searchKeyType.FirstNameLength.ToString();
}
// Отчество
chbUseMiddleName.Checked = searchKeyType.MiddleName;
if (chbUseMiddleName.Checked)
{
tbMiddleNameLength.Enabled = true;
tbMiddleNameLength.Text = searchKeyType.MiddleNameLength.ToString();
}
// Дата рождения
chbUseBirthDate.Checked = searchKeyType.Birthday;
if (chbUseBirthDate.Checked)
{
ddlBirtdateLength.Enabled = true;
ddlBirtdateLength.SelectedValue = searchKeyType.BirthdayLength.ToString();
}
// Место рождения
chbUseBirthPlace.Checked = searchKeyType.Birthplace;
// СНИЛС
chbUseSnils.Checked = searchKeyType.Snils;
// УДЛ
chbUseUDLType.Checked = searchKeyType.DocumentType;
chbUseUDLSeries.Checked = searchKeyType.DocumentSeries;
chbUseUDLNumber.Checked = searchKeyType.DocumentNumber;
// ОКАТО
chbUseOkato.Checked = searchKeyType.Okato;
// Адрес регистрации
chbUseRegistrationStreet.Checked = searchKeyType.AddressStreet;
if (chbUseRegistrationStreet.Checked)
{
tbRegistrationStreetLength.Enabled = true;
tbRegistrationStreetLength.Text = searchKeyType.AddressStreetLength.ToString();
}
chbUseRegistrationHouse.Checked = searchKeyType.AddressHouse;
chbUseRegistrationRoom.Checked = searchKeyType.AddressRoom;
// Адрес проживания
searchKeyType.AddressStreet2 = chbUseResidenceStreet.Checked;
if (searchKeyType.AddressStreet2)
{
tbResidenceStreetLength.Enabled = true;
tbResidenceStreetLength.Text = searchKeyType.AddressStreetLength2.ToString();
}
searchKeyType.AddressHouse2 = chbUseResidenceHouse.Checked;
searchKeyType.AddressRoom2 = chbUseResidenceRoom.Checked;
// Двойные буквы
chbDeleteTwinChar.Checked = searchKeyType.DeleteTwinChar;
if (chbDeleteTwinChar.Checked)
{
tbTwinChars.Enabled = true;
tbTwinChars.Text = searchKeyType.IdenticalLetters;
}
// Прикрепление
chbInsertion.Checked = searchKeyType.Insertion;
}
/// <summary>
/// The move data from gu i 2 object.
/// </summary>
/// <param name="searchKeyType">
/// The search key type.
/// </param>
private void MoveDataFromGUI2Object(SearchKeyType searchKeyType)
{
// Имя ключа
searchKeyType.Name = tbKeyName.Text;
// Код ключа
searchKeyType.Code = tbKeyCode.Text;
// Тип операции
var operationKey = int.Parse(ddlOperationKey.SelectedValue);
if (operationKey >= 0)
{
searchKeyType.OperationKey = regulatoryService.GetConcept(operationKey);
}
// Фамилия
searchKeyType.LastName = chbUseLastName.Checked;
short length = 0;
short.TryParse(tbLastNameLength.Text, out length);
searchKeyType.LastNameLength = length;
// Имя
searchKeyType.FirstName = chbUseFirstName.Checked;
length = 0;
short.TryParse(tbFirstNameLength.Text, out length);
searchKeyType.FirstNameLength = length;
// Отчество
searchKeyType.MiddleName = chbUseMiddleName.Checked;
length = 0;
short.TryParse(tbMiddleNameLength.Text, out length);
searchKeyType.MiddleNameLength = length;
// Дата рождения
searchKeyType.Birthday = chbUseBirthDate.Checked;
length = 0;
short.TryParse(ddlBirtdateLength.SelectedValue, out length);
searchKeyType.BirthdayLength = length;
// Место рождения
searchKeyType.Birthplace = chbUseBirthPlace.Checked;
// СНИЛС
searchKeyType.Snils = chbUseSnils.Checked;
// УДЛ
searchKeyType.DocumentType = chbUseUDLType.Checked;
searchKeyType.DocumentSeries = chbUseUDLSeries.Checked;
searchKeyType.DocumentNumber = chbUseUDLNumber.Checked;
// ОКАТО
searchKeyType.Okato = chbUseOkato.Checked;
// Адрес регистрации
searchKeyType.AddressStreet = chbUseRegistrationStreet.Checked;
length = 0;
short.TryParse(tbRegistrationStreetLength.Text, out length);
searchKeyType.AddressStreetLength = length;
searchKeyType.AddressHouse = chbUseRegistrationHouse.Checked;
searchKeyType.AddressRoom = chbUseRegistrationRoom.Checked;
// Адрес проживания
searchKeyType.AddressStreet2 = chbUseResidenceStreet.Checked;
length = 0;
short.TryParse(tbResidenceStreetLength.Text, out length);
searchKeyType.AddressStreetLength2 = length;
searchKeyType.AddressHouse2 = chbUseResidenceHouse.Checked;
searchKeyType.AddressRoom2 = chbUseResidenceRoom.Checked;
// Двойные буквы
searchKeyType.DeleteTwinChar = chbDeleteTwinChar.Checked;
searchKeyType.IdenticalLetters = tbTwinChars.Text;
// Прикрепление
searchKeyType.Insertion = chbInsertion.Checked;
}
public void CreateGUI()
{
try
{
settings = settings ? settings : ItemEditorSettings.GetOrCreate();
useDatabase = settings.useDatabase;
VisualElement root = rootVisualElement;
var visualTree = settings.treeUxml;
visualTree.CloneTree(root);
var styleSheet = settings.treeUss;
root.styleSheets.Add(styleSheet);
searchField = root.Q <ToolbarSearchField>("search-input");
searchField.RegisterValueChangedCallback(new EventCallback <ChangeEvent <string> >(evt =>
{
DoSearchDropdown(evt.newValue);
}));
searchDropdown = root.Q <UnityEngine.UIElements.ListView>("search-dropdown");
searchDropdown.makeItem = () => new Label()
{
enableRichText = true
};
searchDropdown.onSelectionChange += OnSearchListSelected;
root.RegisterCallback <PointerDownEvent>(evt =>
{
if (!string.IsNullOrEmpty(searchField.value) && !searchDropdown.Contains(evt.target as VisualElement))
{
searchField.value = string.Empty;
}
});
DoSearchDropdown();
searchSelector = root.Q <DropdownField>("search-selector");
searchSelector.RegisterValueChangedCallback(evt =>
{
keyType = (SearchKeyType)searchSelector.choices.IndexOf(evt.newValue);
});
funcTab = root.Q <TabbedBar>();
funcTab.Refresh(new string[] { "道具", "模板" }, OnFuncTab);
funcTab.onRightClick = OnRightFuncTab;
Button refresh = root.Q <Button>("refresh-button");
refresh.clicked += Refresh;
Button newButton = root.Q <Button>("new-button");
newButton.clicked += OnNewClick;
deleteButton = root.Q <Button>("delete-button");
deleteButton.clicked += OnDeleteClick;
RefreshDeleteButton();
oldItem = root.Q <ObjectField>("old-item");
oldItem.objectType = typeof(ItemBase);
Button oldButton = root.Q <ToolbarButton>("copy-button");
oldButton.clicked += OnCopyClick;
oldButton = root.Q <ToolbarButton>("copy-all-button");
oldButton.clicked += OnCopyAllClick;
listLabel = root.Q <Label>("list-label");
templateSelector = root.Q <DropdownField>("template-dropdown");
templateSelector.RegisterValueChangedCallback(OnTemplateSelected);
RefreshTemplateSelector();
itemList = root.Q <UnityEngine.UIElements.ListView>("item-list");
itemList.selectionType = SelectionType.Multiple;
itemList.makeItem = () =>
{
var label = new Label();
label.AddManipulator(new ContextualMenuManipulator(evt =>
{
if (label.userData is ItemNew item)
{
evt.menu.AppendAction("定位", a => EditorGUIUtility.PingObject(item));
evt.menu.AppendAction("删除", a => DeleteItem(item));
}
}));
return(label);
};
itemList.bindItem = (e, i) =>
{
(e as Label).text = !string.IsNullOrEmpty(items[i].Name) ? items[i].Name : "(未命名道具)";
e.userData = items[i];
};
itemList.onSelectionChange += (os) => OnListItemSelected(os.Select(x => x as ItemNew));
RefreshItems();
templateList = root.Q <UnityEngine.UIElements.ListView>("template-list");
templateList.selectionType = SelectionType.Multiple;
templateList.makeItem = () =>
{
var label = new Label();
label.AddManipulator(new ContextualMenuManipulator(evt =>
{
if (label.userData is ItemTemplate template)
{
evt.menu.AppendAction("定位", a => EditorGUIUtility.PingObject(template));
evt.menu.AppendAction("删除", a => DeleteTemplate(template));
}
}));
return(label);
};
templateList.bindItem = (e, i) =>
{
(e as Label).text = !string.IsNullOrEmpty(templates[i].Name) ? templates[i].Name : "(未命名模板)";
e.userData = templates[i];
};
templateList.onSelectionChange += (os) => OnListTemplateSelected(os.Select(x => x as ItemTemplate));
RefreshTemplates();
rightPanel = root.Q <ScrollView>("right-panel");
itemContainer = root.Q("item-container");
templateContainer = root.Q("template-container");
Undo.undoRedoPerformed += RefreshModules;
funcTab.SetSelected(1);
root.RegisterCallback(new EventCallback <KeyDownEvent>(evt =>
{
if (hasFocus && evt.keyCode == KeyCode.Delete)
{
OnDeleteClick();
}
}));
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
/// <summary>
/// Сохраняет ключ поиска
/// </summary>
/// <param name="keyType">
/// The key Type.
/// </param>
/// <returns>
/// The <see cref="Guid"/> .
/// </returns>
public Guid SaveSearchKeyType(SearchKeyType keyType)
{
return(ObjectFactory.GetInstance <ISearchKeyTypeManager>().SaveSearchKeyType(keyType));
}
/// <summary>
/// The equals bd.
/// </summary>
/// <param name="searchKeyType">
/// The search key type.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private bool EqualsBd(SearchKeyType searchKeyType)
{
using (var session = ObjectFactory.GetInstance <ISessionFactory>().OpenSession())
{
var keyType = session.QueryOver <SearchKeyType>().Where(x => x.Id == searchKeyType.Id).SingleOrDefault();
if (keyType != null)
{
if (keyType.FirstName != searchKeyType.FirstName)
{
return(false);
}
if (keyType.FirstNameLength != searchKeyType.FirstNameLength)
{
return(false);
}
if (keyType.LastName != searchKeyType.LastName)
{
return(false);
}
if (keyType.LastNameLength != searchKeyType.LastNameLength)
{
return(false);
}
if (keyType.MiddleName != searchKeyType.MiddleName)
{
return(false);
}
if (keyType.MiddleNameLength != searchKeyType.MiddleNameLength)
{
return(false);
}
if (keyType.IdenticalLetters != searchKeyType.IdenticalLetters)
{
return(false);
}
if (keyType.Okato != searchKeyType.Okato)
{
return(false);
}
if (keyType.PolisNumber != searchKeyType.PolisNumber)
{
return(false);
}
if (keyType.PolisSeria != searchKeyType.PolisSeria)
{
return(false);
}
if (keyType.PolisType != searchKeyType.PolisType)
{
return(false);
}
if (keyType.Snils != searchKeyType.Snils)
{
return(false);
}
if (keyType.AddressHouse != searchKeyType.AddressHouse)
{
return(false);
}
if (keyType.AddressHouse2 != searchKeyType.AddressHouse2)
{
return(false);
}
if (keyType.AddressRoom != searchKeyType.AddressRoom)
{
return(false);
}
if (keyType.AddressRoom2 != searchKeyType.AddressRoom2)
{
return(false);
}
if (keyType.AddressStreet != searchKeyType.AddressStreet)
{
return(false);
}
if (keyType.AddressStreet2 != searchKeyType.AddressStreet2)
{
return(false);
}
if (keyType.AddressStreetLength != searchKeyType.AddressStreetLength)
{
return(false);
}
if (keyType.AddressStreetLength2 != searchKeyType.AddressStreetLength2)
{
return(false);
}
if (keyType.Birthday != searchKeyType.Birthday)
{
return(false);
}
if (keyType.BirthdayLength != searchKeyType.BirthdayLength)
{
return(false);
}
if (keyType.Birthplace != searchKeyType.Birthplace)
{
return(false);
}
if (keyType.DeleteTwinChar != searchKeyType.DeleteTwinChar)
{
return(false);
}
if (keyType.DocumentNumber != searchKeyType.DocumentNumber)
{
return(false);
}
if (keyType.DocumentSeries != searchKeyType.DocumentSeries)
{
return(false);
}
if (keyType.DocumentType != searchKeyType.DocumentType)
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Дубликаты по критерию для разбивки постранично
/// </summary>
/// <param name="criteria">
/// The criteria.
/// </param>
/// <returns>
/// The
/// <see>
/// <cref>SearchResult</cref>
/// </see>
/// .
/// </returns>
public SearchResult <Twin> GetTwins(SearchTwinCriteria criteria)
{
var session = ObjectFactory.GetInstance <ISessionFactory>().GetCurrentSession();
var currentUser = ObjectFactory.GetInstance <ISecurityProvider>().GetCurrentUser();
Concept twinType = null;
InsuredPerson insuredPerson1 = null;
MedicalInsurance medicalInsurance1 = null;
Organisation smo1 = null;
InsuredPerson insuredPerson2 = null;
MedicalInsurance medicalInsurance2 = null;
Organisation smo2 = null;
var query =
session.QueryOver <Twin>()
.JoinAlias(x => x.TwinType, () => twinType)
.Where(x => twinType.Id == TypeTwin.TypeTwin2);
if (currentUser.HasTf())
{
var tf = currentUser.GetTf();
query.JoinAlias(x => x.FirstInsuredPerson, () => insuredPerson1)
.JoinAlias(() => insuredPerson1.MedicalInsurances, () => medicalInsurance1)
.JoinAlias(() => medicalInsurance1.Smo, () => smo1)
.And(() => medicalInsurance1.IsActive)
.And(() => smo1.Parent.Id == tf.Id)
.JoinAlias(x => x.SecondInsuredPerson, () => insuredPerson2)
.JoinAlias(() => insuredPerson2.MedicalInsurances, () => medicalInsurance2)
.JoinAlias(() => medicalInsurance2.Smo, () => smo2)
.And(() => medicalInsurance2.IsActive)
.And(() => smo2.Parent.Id == tf.Id);
}
TwinsKey twinKeys = null;
SearchKeyType skt = null;
switch (criteria.KeyType)
{
case TwinKeyType.All:
break;
case TwinKeyType.Standard:
query.JoinAlias(t => t.TwinsKeys, () => twinKeys)
.JoinAlias(t => twinKeys.KeyType, () => skt)
.WhereRestrictionOn(t => skt.Tfoms)
.IsNull();
break;
case TwinKeyType.NonStandard:
query.JoinAlias(t => t.TwinsKeys, () => twinKeys).Where(t => twinKeys.KeyType.Id == criteria.KeyId);
break;
}
var count = query.RowCount();
var searchResult = new SearchResult <Twin> {
Skip = criteria.Skip, Total = count
};
query.Skip(criteria.Skip).Take(criteria.Take);
searchResult.Rows = query.List();
return(searchResult);
}
