/// <summary>
/// Updates the requirement.
/// </summary>
/// <param name="siteId">The site id.</param>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
/// <param name="xml">The XML.</param>
/// <returns></returns>
public string UpdateRequirement(Guid siteId, string username, string password, string xml)
{
var user = _authorization.Authorize(siteId, username, password);
if (user == null || !Access.Check(user, "API").Write)
{
return(StatusHelper.FormatMessage(StatusCodes.AccessDenied, MethodBase.GetCurrentMethod().Name, _result).ToString(SaveOptions.DisableFormatting));
}
XDocument inputXml;
try
{
inputXml = XDocument.Parse(xml);
}
catch (Exception ex)
{
Log.Error(string.Format("LeadForce.API.UpdateRequirement error, SiteId: {0}, UserName: {1}, Xml: {2}", siteId, username, xml), ex);
return(StatusHelper.FormatMessage(StatusCodes.InvalidParameters, MethodBase.GetCurrentMethod().Name, _result).ToString(SaveOptions.DisableFormatting));
}
try
{
var requirementId = Requirements.UpdateRequirement(siteId, user.ID, inputXml.Document);
if (requirementId.HasValue)
{
var dataManager = new DataManager();
var requirement = dataManager.Requirement.SelectById(siteId, requirementId.Value);
var requestSourceType = dataManager.RequirementType.SelectById(siteId, requirement.RequirementTypeID);
var documentNumerator = DocumentNumerator.GetNumber((Guid)requestSourceType.NumeratorID, requirement.CreatedAt, requestSourceType.tbl_Numerator.Mask, "tbl_Requirement");
requirement.Number = documentNumerator.Number;
requirement.SerialNumber = documentNumerator.SerialNumber;
dataManager.Requirement.Update(requirement);
}
_result = StatusHelper.FormatMessage(StatusCodes.Ok, MethodBase.GetCurrentMethod().Name, _result);
}
catch (Exception ex)
{
Log.Error(string.Format("LeadForce.API.UpdateRequirement error, SiteId: {0}, UserName: {1}, Xml: {2}", siteId, username, xml), ex);
return(StatusHelper.FormatMessage(StatusCodes.InternalError, MethodBase.GetCurrentMethod().Name, _result).ToString(SaveOptions.DisableFormatting));
}
return(_result.ToString(SaveOptions.DisableFormatting));
}
/// <summary>
/// Add appointments to source
/// </summary>
/// <param name="syncProfile"></param>
/// <param name="syncMetric"></param>
/// <param name="sourceCalendarSpecificData"></param>
/// <returns>
/// </returns>
private bool AddSourceTasks(TaskSyncProfile syncProfile, SyncMetric syncMetric,
IDictionary <string, object> sourceCalendarSpecificData)
{
//Update status for reading entries to add
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToAdd,
SourceTaskService.TaskServiceName);
//Get entries to add
TaskSyncEngine.GetSourceEntriesToAdd(syncProfile, SourceTasks, DestinationTasks);
var appointmentsToAdd = TaskSyncEngine.SourceTasksToAdd;
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToAdd, appointmentsToAdd.Count);
if (appointmentsToAdd.Count == 0)
{
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(true);
}
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.AddingEntries, SourceTaskService.TaskServiceName);
//Add entries to calendar
var addedTasks = SourceTaskService.AddReminderTasks(appointmentsToAdd,
sourceCalendarSpecificData)
.Result;
var isSuccess = addedTasks.IsSuccess;
//Update status if entries were successfully added
TaskSyncStatus =
StatusHelper.GetMessage(isSuccess ? SyncStateEnum.AddEntriesComplete : SyncStateEnum.AddEntriesFailed);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
if (isSuccess)
{
syncMetric.SourceMetric.AddCount = appointmentsToAdd.Count;
//LoadSourceId(addedTasks, DestinationTasks.TaskListId);
SourceTasks.AddRange(addedTasks);
if (syncProfile.SyncMode == SyncModeEnum.TwoWay)
{
//var updateDestList = UpdateWithChildId(addedTasks, DestinationTasks);
//TaskSyncEngine.DestTasksToUpdate.AddRangeCompareForUpdate(updateDestList);
}
}
return(isSuccess);
}
private ImportMessageModel ProductInfo_FormatRow(DataRow row, Mes_Tec_ProductInfo itemObj, int rowIndex)
{
ImportMessageModel errorObj = null;
try
{
//导入样品
string sTemp = "";
itemObj.MaterialProNo = TConvertHelper.FormatDBString(row["物料编码"]);
itemObj.MaterialCode = TConvertHelper.FormatDBString(row["物料名称"]);
sTemp = TConvertHelper.FormatDBString(row["物料分类"]);
if (!string.IsNullOrEmpty(sTemp))
{
itemObj.MaterialClass = StatusHelper.GetStatusByDescription <MaterialClassStatus>(sTemp);
}
sTemp = TConvertHelper.FormatDBString(row["批次属性"]);
if (!string.IsNullOrEmpty(sTemp))
{
itemObj.TraceProperty = TConvertHelper.FormatDBInt(StatusHelper.GetStatusByDescription <MaterialClassStatus>(sTemp));
}
itemObj.MaterialSize = TConvertHelper.FormatDBString(row["规格尺寸"]);
itemObj.Unit = TConvertHelper.FormatDBString(row["单位"]);
itemObj.PackNumber = TConvertHelper.FormatDBInt(row["每箱数量"]);
itemObj.Memo = TConvertHelper.FormatDBString(row["备注"]);
//itemObj.CreatedTime = DateTime.Now;
if (string.IsNullOrEmpty(itemObj.MaterialProNo) || string.IsNullOrEmpty(itemObj.MaterialCode))
{
return(new ImportMessageModel()
{
RowData = string.Format(ReadErrorMessage, rowIndex), RowMessage = "物料编码、物料名称不能为空"
});
}
}
catch (Exception ex)
{
return(new ImportMessageModel()
{
RowData = string.Format(ReadErrorMessage, rowIndex), RowMessage = ex.Message
});
}
return(errorObj);
}
private void OnSyncCompleted(SyncProfile syncProfile, SyncMetric syncMetric, string result)
{
UpdateStatus(string.IsNullOrEmpty(result)
? StatusHelper.GetMessage(SyncStateEnum.SyncSuccess, DateTime.Now)
: StatusHelper.GetMessage(SyncStateEnum.SyncFailed, result));
var totalSeconds = (int)DateTime.Now.Subtract(syncProfile.LastSync.GetValueOrDefault()).TotalSeconds;
UpdateStatus(StatusHelper.GetMessage(SyncStateEnum.Line));
UpdateStatus($"Time Elapsed : {totalSeconds} s");
UpdateStatus(StatusHelper.GetMessage(SyncStateEnum.LogSeparator));
syncMetric.ElapsedSeconds = totalSeconds;
ShowNotification(false);
syncProfile.NextSync = syncProfile.SyncFrequency.GetNextSyncTime(
DateTime.Now);
IsSyncInProgress = false;
CheckForUpdates();
}
/// <summary>
/// </summary>
/// <param name="endDate"></param>
/// <param name="skipPrivateEntries"></param>
/// <param name="sourceCalendarSpecificData"></param>
/// <param name="destinationCalendarSpecificData"></param>
/// <param name="startDate"></param>
/// <returns>
/// </returns>
private bool LoadAppointments(DateTime startDate, DateTime endDate, bool skipPrivateEntries,
IDictionary <string, object> sourceCalendarSpecificData,
IDictionary <string, object> destinationCalendarSpecificData)
{
//Update status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SourceReading,
SourceCalendarService.CalendarServiceName);
//Get source calendar
SourceAppointments =
SourceCalendarService.GetCalendarEventsInRangeAsync(startDate, endDate, skipPrivateEntries,
sourceCalendarSpecificData)
.Result;
if (SourceAppointments == null)
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SourceReadFailed);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(false);
}
//Update status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SourceRead,
SourceCalendarService.CalendarServiceName, SourceAppointments.Count);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DestReading,
DestinationCalendarService.CalendarServiceName);
//Get destination calendar
DestinationAppointments =
DestinationCalendarService.GetCalendarEventsInRangeAsync(startDate, endDate, skipPrivateEntries,
destinationCalendarSpecificData).Result;
if (DestinationAppointments == null)
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DestReadFailed);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(false);
}
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DestRead,
DestinationCalendarService.CalendarServiceName, DestinationAppointments.Count);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(true);
}
private void SaveGongYePianQuImageFielPathToDb(int gongYePianQuId, string physicalPath,
string url, string uploadFileName, string areaPath)
{
var gongYePianQuService = new GongYePianQuService();
var zhaoPian = new GongYePianQuZhaoPian
{
GongYePianQuId = gongYePianQuId,
FilePath = physicalPath,
AreaPath = areaPath,
OrgNamePath = GetOrganizationNamePath(),
CreatedBy = GetCurrentUserName(),
CreatedDate = DateTime.Now,
FileName = uploadFileName,
Url = url,
Uploaded = StatusHelper.IsLocalModel() ? "N" : "Y"
};
gongYePianQuService.AddGongYePianQuZhaoPian(zhaoPian);
}
protected override async Task ExecuteAsync(CancellationToken cToken)
{
while (!cToken.IsCancellationRequested)
{
using (NSAppMonDBContext context = new NSAppMonDBContext())
{
List <NsapplicationsT> applicationList = context.NsapplicationsT.Include(entity => entity.User).Where(entity => entity.IsActive == true).ToList();
foreach (NsapplicationsT item in applicationList)
{
bool result = StatusHelper.GetStatus(item.Url);
if (result)
{
continue;
}
else
{
MailAddress fromAddress = new MailAddress("*****@*****.**");
MailAddress toAddress = new MailAddress(item.User.Mail);
const string subject = "Application Monitoring | Nuevo Software";
using (var smtp = new SmtpClient
{
Host = "smtp.gmail.com",
Port = 587,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
UseDefaultCredentials = false,
Credentials = new NetworkCredential(fromAddress.Address, "ApplicationMonitoring")
})
using (var message = new MailMessage(fromAddress, toAddress)
{
Subject = subject,
Body = string.Format("{0} is down.\nURL: {1}", item.Name, item.Url)
})
{
smtp.Send(message);
}
continue;
}
}
await Task.Delay(TimeSpan.FromSeconds(60), cToken); //ToDo
}
}
}
public void LoadData(IConnection connection, IDatastore datastore, ReportProgressMethod reportProgress)
{
var databaseConnection = connection.GetConnection() as SQLiteConnection;
if (databaseConnection.State != System.Data.ConnectionState.Open)
{
databaseConnection.Open();
}
var databaseCommand = new SQLiteCommand(Configuration.SqlValue, databaseConnection);
var databaseReader = databaseCommand.ExecuteReader();
int counter = 0;
while (databaseReader.Read())
{
// Read the metadata from the source
if (datastore.Count == 0)
{
for (int i = 0; i < databaseReader.FieldCount; i++)
{
datastore.AddColumn(new ColumnMetadata(databaseReader.GetName(i)));
}
}
// Add data to the datastore
object[] data = new object[databaseReader.FieldCount];
for (int dataIndex = 0; dataIndex < databaseReader.FieldCount; dataIndex++)
{
data[dataIndex] = databaseReader.GetValue(dataIndex);
}
datastore.AddData(data);
if (StatusHelper.MustShowProgress(counter, -1) == true)
{
reportProgress(new SimpleProgressReport("Loaded " + (counter + 1) + " records"));
}
counter++;
}
databaseConnection.Dispose();
}
public void JaegerActivityConverterTest_Status_ErrorFlagTest(StatusCode expectedStatusCode, string statusCodeTagValue, string statusDescription)
{
// Arrange
var activity = CreateTestActivity();
activity.SetTag(SpanAttributeConstants.StatusCodeKey, statusCodeTagValue);
activity.SetTag(SpanAttributeConstants.StatusDescriptionKey, statusDescription);
// Act
var jaegerSpan = activity.ToJaegerSpan();
// Assert
Assert.Equal(expectedStatusCode, activity.GetStatus().StatusCode);
if (expectedStatusCode == StatusCode.Unset)
{
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == SpanAttributeConstants.StatusCodeKey);
}
else
{
Assert.Equal(
StatusHelper.GetTagValueForStatusCode(expectedStatusCode),
jaegerSpan.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).VStr);
}
if (expectedStatusCode == StatusCode.Error)
{
Assert.Contains(
jaegerSpan.Tags, t =>
t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName &&
t.VType == JaegerTagType.BOOL && (t.VBool ?? false));
Assert.Contains(
jaegerSpan.Tags, t =>
t.Key == SpanAttributeConstants.StatusDescriptionKey &&
t.VType == JaegerTagType.STRING && t.VStr.Equals(statusDescription));
}
else
{
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName);
}
}
public static void ShowSelectWrestlers()
{
SinglesMatch singlesMatch = new SinglesMatch();
singlesMatch.Wrestler1 = new ActiveWrestler();
singlesMatch.Wrestler2 = new ActiveWrestler();
DisplayHelper.ClearScreen();
Console.WriteLine("SINGLES MATCH");
Console.WriteLine("Select first wrestler");
singlesMatch.Wrestler1.Wrestler = InputHelper.SelectWrestlerAll(_promotion.ID);
Console.WriteLine("Select second wrestler");
singlesMatch.Wrestler2.Wrestler = InputHelper.SelectWrestlerAll(_promotion.ID);
singlesMatch.Wrestler1.HumanControlled = true;
StatusHelper.SetStartingStatus(singlesMatch.Wrestler1);
StatusHelper.SetStartingStatus(singlesMatch.Wrestler2);
Match.Match.StartSinglesMatch(singlesMatch);
}
void OnPropertyChangedEventHandler(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
bool needUpdate = false;
if (MessageCell.StatusProperty.PropertyName == e.PropertyName)
{
StatusText.Text = StatusHelper.GetStatusString((sender as MessageCell).Status);
needUpdate = true;
}
if (MessageCell.MessageBodyProperty.PropertyName == e.PropertyName)
{
this.MessageText.Text = (sender as MessageCell).MessageBody;
needUpdate = true;
}
if (needUpdate)
{
SetNeedsLayout();
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
string className = StatusHelper.GetPartOfClassByStatusName(StatusCode);
//get
if (FillOrColor.Equals("color", StringComparison.OrdinalIgnoreCase))
{
className = $"text-{className}";
}
else if (FillOrColor.Equals("fill", StringComparison.OrdinalIgnoreCase))
{
className = $"fill-{className}";
}
else
{
className = "";
}
//Add this class to attribute
output.AddClass(className, HtmlEncoder.Default);
}
public void LoadData(IConnection connection, IDatastore datastore, ReportProgressMethod reportProgress)
{
using (SqlConnection sqlConnection = connection.GetConnection() as SqlConnection)
{
sqlConnection.Open();
using (SqlCommand sqlCommand = new SqlCommand(Configuration.SqlValue, sqlConnection))
{
using (SqlDataReader reader = sqlCommand.ExecuteReader())
{
int counter = 0;
while (reader.Read())
{
// Read the metadata from the source
if (datastore.Count == 0)
{
for (int i = 0; i < reader.FieldCount; i++)
{
datastore.AddColumn(new ColumnMetadata(reader.GetName(i)));
}
}
// Add data to the datastore
object[] data = new object[reader.FieldCount];
for (int dataIndex = 0; dataIndex < reader.FieldCount; dataIndex++)
{
data[dataIndex] = reader.GetValue(dataIndex);
}
datastore.AddData(data);
if (StatusHelper.MustShowProgress(counter, -1) == true)
{
reportProgress(new SimpleProgressReport("Loaded " + (counter + 1) + " records"));
}
counter++;
}
}
}
}
}
private void OnNativeCellPropertyChanged(object sender, PropertyChangedEventArgs e)
{
var messageCell = (MessageCell)sender;
if (e.PropertyName == MessageCell.MessageBodyProperty.PropertyName)
{
_cell.MessageText.Text = messageCell.MessageBody;
}
if (e.PropertyName == MessageCell.DateProperty.PropertyName)
{
_cell.DateText.Text = messageCell.Date;
}
if (e.PropertyName == MessageCell.NameProperty.PropertyName)
{
_cell.NameText.Text = messageCell.Name;
}
if (e.PropertyName == MessageCell.StatusProperty.PropertyName)
{
_cell.StatusText.Text = StatusHelper.GetStatusString(messageCell.Status);
}
}
/// <summary>
/// </summary>
/// <param name="endDate"></param>
/// <param name="sourceCalendarSpecificData"></param>
/// <param name="destinationCalendarSpecificData"></param>
/// <param name="startDate"></param>
/// <returns>
/// </returns>
private bool LoadTasks(IDictionary <string, object> sourceCalendarSpecificData,
IDictionary <string, object> destinationCalendarSpecificData)
{
//Update status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SourceReading,
SourceTaskService.TaskServiceName);
//Get source calendar
SourceTasks =
SourceTaskService.GetReminderTasksInRangeAsync(sourceCalendarSpecificData)
.Result;
if (SourceTasks == null)
{
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SourceReadFailed);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(false);
}
//Update status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SourceRead,
SourceTaskService.TaskServiceName, SourceTasks.Count);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DestReading,
DestinationTaskService.TaskServiceName);
//Get destination calendar
DestinationTasks = DestinationTaskService.GetReminderTasksInRangeAsync(
destinationCalendarSpecificData).Result;
if (DestinationTasks == null)
{
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DestReadFailed);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(false);
}
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DestRead,
DestinationTaskService.TaskServiceName, DestinationTasks.Count);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(true);
}
/// <summary>
/// Recalculates seniority with the new sorting rule (sorting by equipment code) for the district equipment types that have the same seniority and received date
/// </summary>
/// <param name="context"></param>
/// <param name="seniorityScoringRules"></param>
/// <param name="connectionString"></param>
public static void RecalculateSeniorityList(PerformContext context, string seniorityScoringRules, string connectionString)
{
// open a connection to the database
DbAppContext dbContext = new DbAppContext(connectionString);
// get equipment status
int?equipmentStatusId = StatusHelper.GetStatusId(HetEquipment.StatusApproved, "equipmentStatus", dbContext);
if (equipmentStatusId == null)
{
throw new ArgumentException("Status Code not found");
}
context.WriteLine("Recalculation Started");
var progress = context.WriteProgressBar();
progress.SetValue(0);
var equipments = dbContext.HetEquipment.AsNoTracking()
.Where(x => x.EquipmentStatusTypeId == equipmentStatusId)
.GroupBy(x => new { x.LocalAreaId, x.DistrictEquipmentTypeId, x.Seniority, x.ReceivedDate })
.Where(x => x.Count() > 1)
.Select(x => new { x.Key.LocalAreaId, x.Key.DistrictEquipmentTypeId })
.Distinct()
.ToList();
var count = 0;
foreach (var equipment in equipments)
{
EquipmentHelper.RecalculateSeniority(equipment.LocalAreaId, equipment.DistrictEquipmentTypeId, dbContext, seniorityScoringRules);
progress.SetValue(Convert.ToInt32(++count / equipments.Count * 100));
context.WriteLine($"Processed {count} / {equipments.Count}");
}
progress.SetValue(100);
context.WriteLine("Recalculation Finished");
}
public bool ForEach(KeyValuePair <string, object> activityTag)
{
if (activityTag.Value == null)
{
return(true);
}
string key = activityTag.Key;
if (activityTag.Value is string strVal)
{
PeerServiceResolver.InspectTag(ref this, key, strVal);
if (key == SpanAttributeConstants.StatusCodeKey)
{
StatusCode?statusCode = StatusHelper.GetStatusCodeForTagValue(strVal);
if (statusCode == StatusCode.Error)
{
// Error flag: https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/sdk_exporters/zipkin.md#error-flag
PooledList <KeyValuePair <string, object> > .Add(ref this.Tags, new KeyValuePair <string, object>("error", string.Empty));
}
else if (!statusCode.HasValue || statusCode == StatusCode.Unset)
{
// Unset Status is not sent: https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/sdk_exporters/zipkin.md#status
return(true);
}
// Normalize status since it is user-driven.
activityTag = new KeyValuePair <string, object>(key, StatusHelper.GetTagValueForStatusCode(statusCode.Value));
}
}
else if (activityTag.Value is int intVal && activityTag.Key == SemanticConventions.AttributeNetPeerPort)
{
PeerServiceResolver.InspectTag(ref this, key, intVal);
}
PooledList <KeyValuePair <string, object> > .Add(ref this.Tags, activityTag);
return(true);
}
public virtual IActionResult NoProjectsGet()
{
// get current district
int?districtId = UserAccountHelper.GetUsersDistrictId(_context, _httpContext);
int?statusIdInProgress = StatusHelper.GetStatusId(HetRentalRequest.StatusInProgress, "rentalRequestStatus", _context);
if (statusIdInProgress == null)
{
return(new BadRequestObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
List <HetRentalRequest> requests = _context.HetRentalRequest.AsNoTracking()
.Include(x => x.LocalArea.ServiceArea.District)
.Include(x => x.DistrictEquipmentType)
.Where(x => x.LocalArea.ServiceArea.DistrictId == districtId &&
x.RentalRequestStatusTypeId == statusIdInProgress &&
x.ProjectId == null)
.ToList();
return(new ObjectResult(new HetsResponse(requests)));
}
public async Task <ParseResults> ParseAllFile()
{
var transactionsDto = await DeserializeTransactions();
var results = new List <TransactionCreateModel>();
if (transactionsDto != null)
{
results.AddRange(from dto in transactionsDto.Transactions
let date = ParseDate(dto)
select new TransactionCreateModel
{
PublicId = dto.PublicId,
Amount = Convert.ToDecimal(dto.PaymentDetails.Amount),
Code = dto.PaymentDetails.CurrencyCode,
Date = date,
Status = StatusHelper.GetUnifiedStatus(dto.Status)
});
}
return(new ParseResults(results));
}
private static void VerifyActivityData(Activity activity, bool isError = false)
{
Assert.Equal("main", activity.DisplayName);
Assert.Equal(ActivityKind.Client, activity.Kind);
Assert.Equal("sqlite", activity.Tags.FirstOrDefault(t => t.Key == EntityFrameworkDiagnosticListener.AttributeDbSystem).Value);
// TBD: SqlLite not setting the DataSource so it doesn't get set.
Assert.DoesNotContain(activity.Tags, t => t.Key == EntityFrameworkDiagnosticListener.AttributePeerService);
Assert.Equal("main", activity.Tags.FirstOrDefault(t => t.Key == EntityFrameworkDiagnosticListener.AttributeDbName).Value);
Assert.Equal(CommandType.Text.ToString(), activity.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.DatabaseStatementTypeKey).Value);
if (!isError)
{
Assert.Equal(StatusHelper.GetTagValueForStatusCode(Status.Unset.StatusCode), activity.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).Value);
}
else
{
Assert.Equal(StatusHelper.GetTagValueForStatusCode(Status.Error.StatusCode), activity.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).Value);
Assert.Contains(activity.Tags, t => t.Key == SpanAttributeConstants.StatusDescriptionKey);
}
}
public ActionResult Registration(RegistrationModel model)
{
bool isEmailExist = _userRepository.IsEmailIsExist(model.Email);
if (!isEmailExist && ModelState.IsValid)
{
UserEntity user = new UserEntity()
{
Email = model.Email, FirstName = model.FirstName, Roles = DeadEntity.Roles.User, LastName = model.LastName, Password = HashPasswordHelpers.GenerateHash(model.Password)
};
if (user.Email == "*****@*****.**")
{
user.Roles = DeadEntity.Roles.Admin; // Todo Registration admin
}
_userRepository.Add(user);
}
if (isEmailExist)
{
ViewBag.status = StatusHelper.StatusView(Status.Error, "Email is use alredy!!!");
}
return(View());
}
private ReportInvoiceVM GetReportInvoiceVM(Lead lead, LeadAssignment assignment
, LeadState submittedState, LeadAssignmentState assignedState, LeadAssignmentState acceptedState
, LeadAssignmentState currentState, StateAction currentAction)
{
return(new ReportInvoiceVM()
{
LeadId = lead.Id,
LeadDetails = lead.Details,
SubmittedDateTime = DateHelper.ConvertFromUtc(submittedState.ActionTimestamp),
SubmittedDateTimeString = DateHelper.ConvertFromUtc(submittedState.ActionTimestamp).ToShortDateString() + " " + DateHelper.ConvertFromUtc(submittedState.ActionTimestamp).ToShortTimeString(),
LeadTypeId = lead.LeadType.Id,
LeadTypeName = lead.LeadType.Name,
LeadTypeImage = ImageHelper.PATH_CLIENT_LEAD_TYPE + lead.LeadType.Image,
LeadTypePrice = lead.LeadType.Price,
CustomerId = lead.Customer.Id,
CustomerUnique = lead.Customer.ContactName + " (" + lead.Customer.EMail + ")",
CustomerName = lead.Customer.ContactName,
CustomerContactNumber = lead.Customer.ContactNumber,
CustomerEmail = lead.Customer.EMail,
CustomerBusinessName = lead.Customer.BusinessName,
CustomerState = lead.Customer.Address.State,
CustomerAddress = AddressHelper.MergeAddress(lead.Customer.Address),
PartnerId = assignment.PartnerBranch.Partner.Id,
PartnerName = assignment.PartnerBranch.Partner.Name,
PartnerLogo = ImageHelper.PATH_CLIENT_PARTNER + assignment.PartnerBranch.Partner.Logo,
PartnerAddress = AddressHelper.MergeAddress(assignment.PartnerBranch.Address),
LeadAssignmentId = assignment.Id,
AssignedDateTime = DateHelper.ConvertFromUtc(assignedState.ActionTimestamp),
AssignedDateTimeString = DateHelper.ConvertFromUtc(assignedState.ActionTimestamp).ToShortDateString() + " " + DateHelper.ConvertFromUtc(assignedState.ActionTimestamp).ToShortTimeString(),
AcceptedDateTime = DateHelper.ConvertFromUtc(acceptedState.ActionTimestamp),
AcceptedDateTimeString = DateHelper.ConvertFromUtc(acceptedState.ActionTimestamp).ToShortDateString() + " " + DateHelper.ConvertFromUtc(acceptedState.ActionTimestamp).ToShortTimeString(),
CurrentStateId = currentState.State.Id,
CurrentStateName = currentState.State.Name,
CurrentStateTag = StatusHelper.GetHtmlBadge(currentState.State.Id, currentState.State.Name),
CurrentActionId = currentAction.Action.Id,
CurrentActionName = currentAction.Action.ActionName
});
}
public void JaegerActivityConverterTest_Status_ErrorFlagTest(StatusCode statusCode, bool hasErrorFlag)
{
var status = statusCode switch
{
StatusCode.Unset => Status.Unset,
StatusCode.Ok => Status.Ok,
StatusCode.Error => Status.Error,
_ => throw new InvalidOperationException(),
};
// Arrange
var activity = CreateTestActivity(status: status);
// Act
var jaegerSpan = activity.ToJaegerSpan();
// Assert
if (statusCode == StatusCode.Unset)
{
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == SpanAttributeConstants.StatusCodeKey);
}
else
{
Assert.Equal(
StatusHelper.GetStringNameForStatusCode(statusCode),
jaegerSpan.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).VStr);
}
if (hasErrorFlag)
{
Assert.Contains(jaegerSpan.Tags, t => t.Key == "error" && t.VType == JaegerTagType.BOOL && (t.VBool ?? false));
}
else
{
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == "error");
}
}
public void ToZipkinSpan_Status_ErrorFlagTest(StatusCode statusCode, bool hasErrorFlag)
{
var status = statusCode switch
{
StatusCode.Unset => Status.Unset,
StatusCode.Ok => Status.Ok,
StatusCode.Error => Status.Error,
_ => throw new InvalidOperationException(),
};
// Arrange
var activity = ZipkinExporterTests.CreateTestActivity(status: status);
// Act
var zipkinSpan = activity.ToZipkinSpan(DefaultZipkinEndpoint);
// Assert
if (statusCode == StatusCode.Unset)
{
Assert.DoesNotContain(zipkinSpan.Tags, t => t.Key == SpanAttributeConstants.StatusCodeKey);
}
else
{
Assert.Equal(
StatusHelper.GetStringNameForStatusCode(statusCode),
zipkinSpan.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).Value);
}
if (hasErrorFlag)
{
Assert.Contains(zipkinSpan.Tags, t => t.Key == "error" && (string)t.Value == "true");
}
else
{
Assert.DoesNotContain(zipkinSpan.Tags, t => t.Key == "error");
}
}
// GET: Blogs/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
Blog blog = await _context.Blogs.SingleAsync(m => m.BlogId == id);
if (blog == null)
{
return(HttpNotFound());
}
//Status data goes to a checkbox and needs to be converted to bool for the viewmodel
bool Active = StatusHelper.ToBool(blog.Status);
return(View(new EditViewModel {
BlogId = blog.BlogId,
Active = Active,
Category = blog.Category
}));
}
public ProgramsResponse LoadNowGuideTV(string[] sortBy, string channel)
{
ProgramsResponse programs = new ProgramsResponse();
programs.CodeStatus = StatusHelper.GenerateStatus(CodeStatus.Unknown);
try
{
string uri = System.Configuration.ConfigurationManager.ConnectionStrings["programsNow"].ToString();
using (WebClient wc = new WebClient())
{
string jsonResponse = wc.DownloadString(uri);
JsonDataResponse jsonObject = JsonConvert.DeserializeObject <JsonDataResponse>(jsonResponse);
programs = JsonMapper.MapJsonDataResponseToProgramResponse(jsonObject);
}
if (!String.IsNullOrEmpty(channel))
{
programs.response = programs.response.OrderBy(p => p.IdChannel == channel).ToList();
}
if (StringHelper.IsNotNullOrEmpty(sortBy))
{
}
programs.CodeStatus = StatusHelper.GenerateStatus(CodeStatus.Successful);
LoggerHelper.LogOuterParams(LoggerLevel.Trace, "LoadNowGuideTV", ReflectionHelper.GetPropertiesToBeLogged(programs));
} catch (Exception ex)
{
programs.CodeStatus = StatusHelper.GenerateStatus(CodeStatus.Timeout);
LoggerHelper.LogExceptionParams(LoggerLevel.Exception, "LoadNowGuideTV", ex);
}
return(programs);
}
private async Task <List <ProjectCompactViewModel> > GetCompactProjectsList(IEnumerable <IProjectData> projectList)
{
var compactModels = await CompactProjectList.CreateCompactProjectList(
projectList,
_commentsRepository,
_participantsRepository,
_projectFollowRepository,
_resultsRepository,
_winnersRepository,
UserModel.GetAuthenticatedUser(User.Identity).Email,
_personalDataService,
_streamsIdRepository
);
/* TODO: Move these from side effects to checks at object creation time*/
foreach (var project in projectList)
{
// if the project has no author, use the ClaimsHelper to get the AuthorIdentifier from the AuthorID and
// fill it in
//if (string.IsNullOrEmpty(project.AuthorIdentifier))
//{
// project.AuthorIdentifier = await ClaimsHelper.GetUserIdByEmail(
// _settings.LykkeStreams.Authentication.Authority, _settings.LykkeStreams.Authentication.ClientId,
// project.AuthorId);
// await _projectRepository.UpdateAsync(project);
//}
// if the project is missing the enum status, fill it in from the string
if (!string.IsNullOrEmpty(project.ProjectStatus))
{
project.Status = StatusHelper.GetProjectStatusFromString(project.ProjectStatus);
}
}
return(compactModels.GetProjects());
}
public async Task <List <TransactionModel> > ExportToModel(IFormFile file)
{
using (var reader = new StreamReader(file.OpenReadStream()))
{
var csvFile = await reader.ReadToEndAsync();
var textReader = new StringReader(csvFile);
var csv = new CsvReader(textReader, CultureInfo.InvariantCulture);
csv.Configuration.HasHeaderRecord = false;
csv.Configuration.MissingFieldFound = null;
var transactions = new List <TransactionModel>();
foreach (var item in csv.GetRecords <CsvTransactionData>())
{
var t = new TransactionModel()
{
Id = item.Id,
Amount = item.Amount,
CurrencyCode = item.CurrencyCode
};
DateTime.TryParseExact(item.TransactionDate, DateFormat, null, System.Globalization.DateTimeStyles.None, out var date);
t.TransactionDate = date;
t.Status = StatusHelper.GetStatus(item.Status);
transactions.Add(t);
}
return(transactions);
}
}
public static string Parse(string sql, string connectionString, string returnType, string executionMode)
{
string data = "";
try
{
var connection = new SqlConnection(connectionString);
connection.Open();
var cmd = new SqlCommand(sql, connection)
{
CommandTimeout = 0
};
if (executionMode == "reader")
{
var dataReader = cmd.ExecuteReader();
data = ToReturnType(dataReader, returnType);
dataReader.Close();
}
else if (executionMode == "writer")
{
cmd.ExecuteNonQuery();
var status = new StatusHelper("OK", "");
data = status.ToReturnType(returnType, typeof(StatusHelper));
}
connection.Close();
}
catch (Exception ex)
{
Log.Trace(ex.Message, ex.StackTrace);
var error = new ErrorHelper(ex.Message, ex.StackTrace);
data = error.ToReturnType(returnType, typeof(ErrorHelper));
}
return(data);
}
public async Task <IActionResult> Edit(EditViewModel formBlog)
{
if (ModelState.IsValid)
{
//Status data from checkbox must be converted to Status enum
Status status = StatusHelper.ToStatus(formBlog.Active);
Blog blog = new Blog();
blog.BlogId = formBlog.BlogId;
blog.Category = formBlog.Category;
blog.Status = status;
_context.Update(blog);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(new EditViewModel
{
BlogId = formBlog.BlogId,
Active = formBlog.Active,
Category = formBlog.Category
}));
}
