public static int CountTrips(StatusFilter statusFilter, string searchKey)
{
var result = 0;
string jsonFilePath = "./Data/trips.json";
var json = File.ReadAllText(jsonFilePath);
try
{
JArray trips = JArray.Parse(json);
string key = searchKey.Trim();
if (key != "")
{
trips = new JArray(trips.Where(trip => trip["Name"].ToString() == key));
}
if (statusFilter == StatusFilter.FINISH)
{
trips = new JArray(trips.Where(trip => trip["Status"].ToString() == "finish"));
}
if (statusFilter == StatusFilter.PROGRESS)
{
trips = new JArray(trips.Where(trip => trip["Status"].ToString() == "progress"));
}
result = trips.Count();
}
catch (Exception)
{
throw;
}
return(result);
}
public async Task <ActionResult <List <CustomerLevel_StatusDTO> > > SingleListStatus([FromBody] CustomerLevel_StatusFilterDTO CustomerLevel_StatusFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
StatusFilter StatusFilter = new StatusFilter();
StatusFilter.Skip = 0;
StatusFilter.Take = int.MaxValue;
StatusFilter.Take = 20;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Selects = StatusSelect.ALL;
List <Status> Statuses = await StatusService.List(StatusFilter);
List <CustomerLevel_StatusDTO> CustomerLevel_StatusDTOs = Statuses
.Select(x => new CustomerLevel_StatusDTO(x)).ToList();
return(CustomerLevel_StatusDTOs);
}
public async Task <ActionResult <List <Position_StatusDTO> > > SingleListStatus([FromBody] Position_StatusFilterDTO Position_StatusFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
StatusFilter StatusFilter = new StatusFilter();
StatusFilter.Skip = 0;
StatusFilter.Take = 20;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.Id = Position_StatusFilterDTO.Id;
StatusFilter.Code = Position_StatusFilterDTO.Code;
StatusFilter.Name = Position_StatusFilterDTO.Name;
List <Status> Statuses = await StatusService.List(StatusFilter);
List <Position_StatusDTO> Position_StatusDTOs = Statuses
.Select(x => new Position_StatusDTO(x)).ToList();
return(Position_StatusDTOs);
}
public async Task <int> Count(StatusFilter filter)
{
IQueryable <StatusDAO> Statuses = DataContext.Status.AsNoTracking();
Statuses = DynamicFilter(Statuses, filter);
return(await Statuses.CountAsync());
}
public async Task <List <KnowledgeGroup_StatusDTO> > FilterListStatus([FromBody] KnowledgeGroup_StatusFilterDTO KnowledgeGroup_StatusFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
StatusFilter StatusFilter = new StatusFilter();
StatusFilter.Skip = 0;
StatusFilter.Take = 20;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.Id = KnowledgeGroup_StatusFilterDTO.Id;
StatusFilter.Code = KnowledgeGroup_StatusFilterDTO.Code;
StatusFilter.Name = KnowledgeGroup_StatusFilterDTO.Name;
List <Status> Statuses = await StatusService.List(StatusFilter);
List <KnowledgeGroup_StatusDTO> KnowledgeGroup_StatusDTOs = Statuses
.Select(x => new KnowledgeGroup_StatusDTO(x)).ToList();
return(KnowledgeGroup_StatusDTOs);
}
/// <summary>
/// Gets friends for the current account.
/// </summary>
/// <param name="filter">Filter friends by status.</param>
/// <param name="limit">The amount of friends to return.</param>
/// <returns>A list of User objects for each friend.</returns>
protected List <User> GetFriends(StatusFilter filter = StatusFilter.All, int limit = 500)
{
var response = Request.SendGetRequest <FriendModel>($"https://us-prof.np.community.playstation.net/userProfile/v1/users/{this.UserParameter}/friends/profiles2?fields=onlineId,accountId,avatarUrls,aboutMe,plus,trophySummary(@default),isOfficiallyVerified,personalDetail(@default,profilePictureUrls),presences(@titleInfo,hasBroadcastData),presences(@titleInfo),friendRelation,consoleAvailability&profilePictureSizes=m&avatarSizes=m&sort=onlineStatus&titleIconSize=s&extendPersonalDetailTarget=true&offset=0&limit={limit}",
this.Client.Tokens.Authorization);
return(response.Profiles.Select(friend => new User(Client, friend)).ToList());
}
protected override void OnInitialize()
{
base.OnInitialize();
AddressSelector.Init();
AddressSelector.Description = "Все накладные";
Bus.Listen <string>("reload").Cast <object>()
.Merge(DbReloadToken)
.Merge(StatusFilter.FilterChanged())
.Merge(AddressSelector.FilterChanged.Cast <object>())
.Merge(OnlyRejected.Changed())
.SelectMany(_ => RxQuery(x => {
var query = x.Query <Stock>().Where(y => y.Quantity != 0 || y.ReservedQuantity != 0);
if (StatusFilter.IsFiltred())
{
var values = StatusFilter.GetValues();
query = query.Where(y => values.Contains(y.Status));
}
if (OnlyRejected.Value)
{
query = query.Where(r => r.RejectStatus == RejectStatus.Defective || r.RejectStatus == RejectStatus.Perhaps);
}
var addresses = AddressSelector.GetActiveFilter().Select(y => y.Id);
query = query.Where(y => addresses.Contains(y.Address.Id));
return(query.Fetch(y => y.Address).OrderBy(y => y.Product).ToList());
}))
.Subscribe(Items, CloseCancellation.Token);
}
private IQueryable <StatusDAO> OrFilter(IQueryable <StatusDAO> query, StatusFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <StatusDAO> initQuery = query.Where(q => false);
foreach (StatusFilter StatusFilter in filter.OrFilter)
{
IQueryable <StatusDAO> queryable = query;
if (StatusFilter.Id != null && StatusFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, StatusFilter.Id);
}
if (StatusFilter.Code != null && StatusFilter.Code.HasValue)
{
queryable = queryable.Where(q => q.Code, StatusFilter.Code);
}
if (StatusFilter.Name != null && StatusFilter.Name.HasValue)
{
queryable = queryable.Where(q => q.Name, StatusFilter.Name);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public async Task <List <SmsTemplate_StatusDTO> > SingleListStatus([FromBody] SmsTemplate_StatusFilterDTO SmsTemplate_StatusFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
StatusFilter StatusFilter = new StatusFilter();
StatusFilter.Skip = 0;
StatusFilter.Take = 20;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.Id = SmsTemplate_StatusFilterDTO.Id;
StatusFilter.Code = SmsTemplate_StatusFilterDTO.Code;
StatusFilter.Name = SmsTemplate_StatusFilterDTO.Name;
List <Status> Statuses = await StatusService.List(StatusFilter);
List <SmsTemplate_StatusDTO> SmsTemplate_StatusDTOs = Statuses
.Select(x => new SmsTemplate_StatusDTO(x)).ToList();
return(SmsTemplate_StatusDTOs);
}
public async void should_filter_on_status()
{
var result = await Subject.Search(null, 0, 10, StatusFilter.Equals(WorkflowStatus.Runnable));
result.Data.Should().NotContain(x => x.Status != WorkflowStatus.Runnable);
result.Data.Should().Contain(x => x.Status == WorkflowStatus.Runnable);
}
public async Task <FileResult> ExportTemplate([FromBody] SmsTemplate_SmsTemplateFilterDTO SmsTemplate_SmsTemplateFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
#region SmsTemplate
var SmsTemplateHeaders = new List <string[]>()
{
new string[] {
"Số thứ tự",
"Mã *",
"Tiêu đề *",
"Nội dung",
"Trạng thái",
}
};
List <object[]> SmsTemplateData = new List <object[]>();
excel.GenerateWorksheet("Mẫu tin nhắn - File template tải mẫu", SmsTemplateHeaders, SmsTemplateData);
#endregion
#region Status
var StatusFilter = new StatusFilter();
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Skip = 0;
StatusFilter.Take = int.MaxValue;
List <Status> Statuses = await StatusService.List(StatusFilter);
var StatusHeaders = new List <string[]>()
{
new string[] {
"Mã",
"Code",
"Name",
}
};
List <object[]> StatusData = new List <object[]>();
for (int i = 0; i < Statuses.Count; i++)
{
var Status = Statuses[i];
StatusData.Add(new Object[]
{
Status.Id,
Status.Code,
Status.Name,
});
}
excel.GenerateWorksheet("Trạng thái tin nhắn", StatusHeaders, StatusData);
#endregion
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "SmsTemplate.xlsx"));
}
public async Task <FileResult> ExportTemplate([FromBody] TicketSource_TicketSourceFilterDTO TicketSource_TicketSourceFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
#region TicketSource
var TicketSourceHeaders = new List <string[]>()
{
new string[] {
"Id",
"Name",
"OrderNumber",
"StatusId",
"Used",
}
};
List <object[]> TicketSourceData = new List <object[]>();
excel.GenerateWorksheet("TicketSource", TicketSourceHeaders, TicketSourceData);
#endregion
#region Status
var StatusFilter = new StatusFilter();
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Skip = 0;
StatusFilter.Take = int.MaxValue;
List <Status> Statuses = await StatusService.List(StatusFilter);
var StatusHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
}
};
List <object[]> StatusData = new List <object[]>();
for (int i = 0; i < Statuses.Count; i++)
{
var Status = Statuses[i];
StatusData.Add(new Object[]
{
Status.Id,
Status.Code,
Status.Name,
});
}
excel.GenerateWorksheet("Status", StatusHeaders, StatusData);
#endregion
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "TicketSource.xlsx"));
}
public async Task <IActionResult> Get(string terms, WorkflowStatus?status, string type, DateTime?createdFrom, DateTime?createdTo, int skip, int take = 10)
{
var filters = new List <SearchFilter>();
if (status.HasValue)
{
filters.Add(StatusFilter.Equals(status.Value));
}
if (createdFrom.HasValue)
{
filters.Add(DateRangeFilter.After(x => x.CreateTime, createdFrom.Value));
}
if (createdTo.HasValue)
{
filters.Add(DateRangeFilter.Before(x => x.CreateTime, createdTo.Value));
}
if (!string.IsNullOrEmpty(type))
{
filters.Add(ScalarFilter.Equals(x => x.WorkflowDefinitionId, type));
}
var result = await _searchService.Search(terms, skip, take, filters.ToArray());
return(Json(result));
}
public BackendPartnerFilter()
{
Name = "";
StatusSelected = StatusFilterEnum.Aktiv;
_statusOptions = new List <StatusFilterEnum>();
StatusOptions = new List <StatusFilterEnum>(StatusFilter.getOptions());
PartnerTypeSelected = all;
_partnerTypeOptions = new List <string>();
}
protected override void RefreshMethod()
{
if (!IsFilterInitialized)
{
Filter = new StatusFilter();
IsFilterInitialized = true;
}
base.RefreshMethod();
}
public List <ReviewInfo> GetReviewsByCategory(int portalID, int categoryID, StatusFilter filter)
{
ProductController productController = new ProductController();
List <ProductInfo> productList = productController.GetCategoryProducts(portalID, categoryID, true, 2, "ASC");
List <ReviewInfo> reviewList = new List <ReviewInfo>();
foreach (ProductInfo productInfo in productList)
{
reviewList.AddRange(GetReviewsByProduct(portalID, productInfo.ProductID, filter));
}
return(reviewList);
}
public async Task <int> Count(StatusFilter StatusFilter)
{
try
{
int result = await UOW.StatusRepository.Count(StatusFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(StatusService));
}
return(0);
}
public async Task <List <Status> > List(StatusFilter filter)
{
if (filter == null)
{
return(new List <Status>());
}
IQueryable <StatusDAO> StatusDAOs = DataContext.Status.AsNoTracking();
StatusDAOs = DynamicFilter(StatusDAOs, filter);
StatusDAOs = DynamicOrder(StatusDAOs, filter);
List <Status> Statuses = await DynamicSelect(StatusDAOs, filter);
return(Statuses);
}
public async Task <List <Status> > List(StatusFilter StatusFilter)
{
try
{
List <Status> Statuss = await UOW.StatusRepository.List(StatusFilter);
return(Statuss);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(StatusService));
}
return(null);
}
//preencher estado
private void PreencherComboBoxEstado()
{
//Limpa a combo box
estadoComboBox.Items.Clear();
//Lista os tipos
String query = "SELECT NOME FROM MD_ESTADO";
query = StatusFilter.StatusNotIn(query);
SqlDataReader reader = connection.Pesquisa(query);
while (reader.Read())
{
estadoComboBox.Items.Add((reader["NOME"].ToString()));
}
reader.Close();
}
//Preencher combo box cep
private void PreencherComboBoxCep()
{
//Limpa a combo box
cepComboBox.Items.Clear();
//Lista os tipos
String query = "SELECT CEP FROM MD_CEP";
query = StatusFilter.StatusNotIn(query);
SqlDataReader reader = connection.Pesquisa(query);
while (reader.Read())
{
cepComboBox.Items.Add((reader["CEP"].ToString()));
}
reader.Close();
}
void ReleaseDesignerOutlets()
{
if (DocRecTable != null)
{
DocRecTable.Dispose();
DocRecTable = null;
}
if (PropertyChooser != null)
{
PropertyChooser.Dispose();
PropertyChooser = null;
}
if (DocRecTableView != null)
{
DocRecTableView.Dispose();
DocRecTableView = null;
}
if (TypeFilter != null)
{
TypeFilter.Dispose();
TypeFilter = null;
}
if (StatusFilter != null)
{
StatusFilter.Dispose();
StatusFilter = null;
}
if (SenderFilter != null)
{
SenderFilter.Dispose();
SenderFilter = null;
}
if (ReceiverFilter != null)
{
ReceiverFilter.Dispose();
ReceiverFilter = null;
}
}
static void Main(string[] args)
{
IServiceProvider serviceProvider = ConfigureServices();
var host = serviceProvider.GetService <IWorkflowHost>();
host.RegisterWorkflow <TestWorkflow, Approval>();
host.Start();
host.OnLifeCycleEvent += Host_OnLifeCycleEvent;
var approval = new Approval
{
UserList = new System.Collections.Generic.List <User>
{
new User(),
new User()
}
};
//var wfId = host.StartWorkflow("TestWorkflow", approval).Result;
var context = serviceProvider.GetService <IWorkflowDbContextFactory>().Build();
//var context = contextFactory.Build();
var ids = context.Set <PersistedWorkflow>()
.Where(p => p.Status == WorkflowStatus.Complete)
.Select(s => s.InstanceId.ToString()).ToList();
// Use efProvider.GetWorkflowInstances
var efProvider = serviceProvider.GetService <IPersistenceProvider>();
//PrintPersistance(efProvider);
//PrintCompleteWorkflow(efProvider);
// Use UseElasticsearch
var searchprovice = serviceProvider.GetService <ISearchIndex>();
var page = searchprovice.Search("", 0, 10, StatusFilter.Equals(WorkflowStatus.Complete)).Result;
PrintCompleteWorkflow(efProvider, page);
while (true)
{
}
;
}
public async Task <bool> ValidateStatus(Role Role)
{
StatusFilter StatusFilter = new StatusFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Role.StatusId
},
Selects = StatusSelect.Id
};
int count = await UOW.StatusRepository.Count(StatusFilter);
if (count == 0)
{
Role.AddError(nameof(RoleValidator), nameof(Role.Status), ErrorCode.StatusNotExisted);
}
return(count != 0);
}
public async Task <List <Role_StatusDTO> > SingleListStatus([FromBody] Role_StatusFilterDTO Role_StatusFilterDTO)
{
StatusFilter StatusFilter = new StatusFilter();
StatusFilter.Skip = 0;
StatusFilter.Take = 20;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.Id = Role_StatusFilterDTO.Id;
StatusFilter.Code = Role_StatusFilterDTO.Code;
StatusFilter.Name = Role_StatusFilterDTO.Name;
List <Status> Statuses = await StatusService.List(StatusFilter);
List <Role_StatusDTO> Role_StatusDTOs = Statuses
.Select(x => new Role_StatusDTO(x)).ToList();
return(Role_StatusDTOs);
}
public async Task <bool> ValidateId(Status Status)
{
StatusFilter StatusFilter = new StatusFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Status.Id
},
Selects = StatusSelect.Id
};
int count = await UOW.StatusRepository.Count(StatusFilter);
if (count == 0)
{
Status.AddError(nameof(StatusValidator), nameof(Status.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <List <AppUser_StatusDTO> > FilterListStatus([FromBody] AppUser_StatusFilterDTO AppUser_StatusFilterDTO)
{
StatusFilter StatusFilter = new StatusFilter();
StatusFilter.Skip = 0;
StatusFilter.Take = 20;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.Id = AppUser_StatusFilterDTO.Id;
StatusFilter.Code = AppUser_StatusFilterDTO.Code;
StatusFilter.Name = AppUser_StatusFilterDTO.Name;
List <Status> Statuses = await StatusService.List(StatusFilter);
List <AppUser_StatusDTO> AppUser_StatusDTOs = Statuses
.Select(x => new AppUser_StatusDTO(x)).ToList();
return(AppUser_StatusDTOs);
}
private IQueryable <StatusDAO> DynamicOrder(IQueryable <StatusDAO> query, StatusFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case StatusOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case StatusOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case StatusOrder.Name:
query = query.OrderBy(q => q.Name);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case StatusOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case StatusOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case StatusOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
public FavoriteListResponse FavoriteList(int?offset = null, int?limit = null,
StatusFilter statusFilter = StatusFilter.all, FileStationFavoriteAddtionalOptions additional = null)
{
dynamic requiredParams = new
{
api = "SYNO.FileStation.Favorite",
version = 1,
method = "list",
offset,
limit,
status_filter = statusFilter
};
var proc = new FuncProcessor <FavoriteListResponse>("/entry.cgi", _session.sid,
requiredParams, new
{
additional = TrueBooleanValuesFromObjectToCommaSeparatedList(additional)
});
return(proc.Run());
}
private IQueryable <StatusDAO> DynamicFilter(IQueryable <StatusDAO> query, StatusFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null && filter.Id.HasValue)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Code != null && filter.Code.HasValue)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.Name != null && filter.Name.HasValue)
{
query = query.Where(q => q.Name, filter.Name);
}
query = OrFilter(query, filter);
return(query);
}
public ArrayList GetReviewsByProduct(int portalID, int productID, StatusFilter filter)
{
return GetFilteredList(CBO.FillCollection(DataProvider.Instance().GetReviewsByProduct(portalID, productID), typeof(ReviewInfo)), filter);
}
private ArrayList GetFilteredList(ArrayList fullList, StatusFilter filter)
{
// Should the list be filtered?
if (filter == StatusFilter.All)
{
return fullList;
}
// Create filtered list
ArrayList filteredList = new ArrayList();
foreach(ReviewInfo reviewInfo in fullList)
{
bool filterByApproved = (filter == StatusFilter.Approved);
if (filterByApproved == reviewInfo.Authorized)
{
filteredList.Add(reviewInfo);
}
}
return filteredList;
}
public ArrayList GetReviews(int portalID, StatusFilter filter)
{
return GetFilteredList(GetReviews(portalID), filter);
}
public ArrayList GetReviewsByCategory(int portalID, int categoryID, StatusFilter filter)
{
ProductController productController = new ProductController();
ArrayList productList = productController.GetCategoryProducts(categoryID, true);
ArrayList reviewList = new ArrayList();
foreach(ProductInfo productInfo in productList)
{
reviewList.AddRange(GetReviewsByProduct(portalID, productInfo.ProductID, filter));
}
return reviewList;
}
/// <summary>
/// Parse the XML document
/// </summary>
/// <param name="filter">Enum StatusFilter</param>
/// <param name="familyName">Family Name of the Patien</param>
/// <returns>Collection of Medication</returns>
public Medication[] Parse(StatusFilter filter, string familyName)
{
List<Medication> medicationList = new List<Medication>();
////XmlNodeList medicationNodes = this.xmlDom.SelectNodes("/Patients/Patient/Medications/Medication");
////Get medications for a specific patient
XmlNodeList medicationNodes = this.xmlDom.SelectNodes("//Medication[ancestor::*/@FamilyName='" + familyName + "']");
bool medicationValid = false;
int index = 1;
if (medicationNodes.Count > 0)
{
foreach (XmlNode medicationNode in medicationNodes)
{
switch (filter)
{
case StatusFilter.Full:
medicationValid = true;
break;
case StatusFilter.Active:
if ((MedicationStatus)Enum.Parse(typeof(MedicationStatus), this.GetAttribute(medicationNode, "Status")) == MedicationStatus.Active)
{
medicationValid = true;
}
break;
case StatusFilter.Suspended:
if ((MedicationStatus)Enum.Parse(typeof(MedicationStatus), this.GetAttribute(medicationNode, "Status")) == MedicationStatus.Suspended)
{
medicationValid = true;
}
break;
}
if (medicationValid)
{
Medication medication = new Medication();
XmlNodeList medicationNameNodes = medicationNode.SelectNodes("MedicationNames/MedicationName");
foreach (XmlNode medicationNameNode in medicationNameNodes)
{
medication.MedicationNames.Add(new MedicationName(this.GetAttribute(medicationNameNode, "Name"), this.GetAttribute(medicationNameNode, "Information")));
index++;
}
medication.CriticalAlertGraphic = this.GetAttribute(medicationNode, "CriticalAlertGraphic");
medication.IndicatorGraphic = this.GetAttribute(medicationNode, "IndicatorGraphic");
medication.Dose = this.GetAttribute(medicationNode, "Dose");
medication.Form = this.GetAttribute(medicationNode, "Form");
medication.Frequency = this.GetAttribute(medicationNode, "Frequency");
medication.Reason = this.GetAttribute(medicationNode, "Reason");
medication.Route = this.GetAttribute(medicationNode, "Route");
medication.MedicationTooltip = this.GetAttribute(medicationNode, "ToolTip");
medication.StartDate = DateTime.ParseExact(
this.GetAttribute(medicationNode, "StartDate"),
new string[] { "dd-MMM-yy", "dd/mm/yyyy" },
CultureInfo.CurrentCulture,
DateTimeStyles.None);
string statusDate = this.GetAttribute(medicationNode, "StatusDate");
if (!string.IsNullOrEmpty(statusDate))
{
medication.StatusDate = DateTime.ParseExact(
statusDate,
new string[] { "dd-MMM-yy", "dd/mm/yyyy" },
CultureInfo.CurrentCulture,
DateTimeStyles.None);
}
medication.Status = (MedicationStatus)Enum.Parse(typeof(MedicationStatus), this.GetAttribute(medicationNode, "Status"));
medicationList.Add(medication);
}
medicationValid = false;
}
}
return medicationList.ToArray();
}
