public static void ExecuteMethod_VerifyValidInput(InformationInput informationInput)
{
if (informationInput.IsValidatedAndActive == false)
{
throw new SecurityException("InformationInput is not active");
}
}
public static void Execute(DeleteInformationInputParameters parameters)
{
PrepareParameters(parameters);
InformationInput InformationInput = DeleteInformationInputImplementation.GetTarget_InformationInput(parameters.Owner, parameters.InformationInputID);
DeleteInformationInputImplementation.ExecuteMethod_DeleteInformationInput(InformationInput);
}
public static void Execute(SetInformationInputValidationAndActiveStatusParameters parameters)
{
PrepareParameters(parameters);
InformationInput InformationInput = SetInformationInputValidationAndActiveStatusImplementation.GetTarget_InformationInput(parameters.Owner, parameters.InformationInputID);
SetInformationInputValidationAndActiveStatusImplementation.ExecuteMethod_SetInputValidAndActiveValue(parameters.IsValidAndActive, InformationInput);
SetInformationInputValidationAndActiveStatusImplementation.ExecuteMethod_StoreObject(InformationInput);
}
public static InformationInput GetTarget_CreatedInformationInput(IContainerOwner owner, string inputDescription, string locationUrl)
{
InformationInput informationInput = new InformationInput();
informationInput.SetLocationAsOwnerContent(owner, informationInput.ID);
informationInput.Description = inputDescription;
informationInput.LocationURL = locationUrl;
return(informationInput);
}
public static InformationInput GetTarget_CreatedInformationInput(IContainerOwner owner, string inputDescription, string locationUrl, string localContentName, string authenticatedDeviceId)
{
InformationInput informationInput = new InformationInput();
informationInput.SetLocationAsOwnerContent(owner, informationInput.ID);
informationInput.InputDescription = inputDescription;
informationInput.LocationURL = locationUrl;
informationInput.LocalContentName = localContentName;
informationInput.AuthenticatedDeviceID = authenticatedDeviceId;
return informationInput;
}
public static CreateInformationInputReturnValue Execute(CreateInformationInputParameters parameters)
{
PrepareParameters(parameters);
InformationInput CreatedInformationInput = CreateInformationInputImplementation.GetTarget_CreatedInformationInput(parameters.Owner, parameters.InputDescription, parameters.LocationURL);
CreateInformationInputImplementation.ExecuteMethod_StoreObject(CreatedInformationInput);
CreateInformationInputReturnValue returnValue = CreateInformationInputImplementation.Get_ReturnValue(CreatedInformationInput);
return(returnValue);
}
public static void Execute(FetchInputInformationParameters parameters)
{
PrepareParameters(parameters);
InformationInput InformationInput = FetchInputInformationImplementation.GetTarget_InformationInput(parameters.Owner, parameters.InformationInputID);
FetchInputInformationImplementation.ExecuteMethod_VerifyValidInput(InformationInput);
string InputFetchLocation = FetchInputInformationImplementation.GetTarget_InputFetchLocation(InformationInput);
string InputFetchName = FetchInputInformationImplementation.GetTarget_InputFetchName(InformationInput);
FetchInputInformationImplementation.ExecuteMethod_FetchInputToStorage(parameters.Owner, parameters.QueryParameters, InformationInput, InputFetchLocation, InputFetchName);
}
public static void Execute(ProcessFetchedInputsParameters parameters)
{
PrepareParameters(parameters);
InformationInput InformationInput = ProcessFetchedInputsImplementation.GetTarget_InformationInput(parameters.Owner, parameters.InformationInputID);
ProcessFetchedInputsImplementation.ExecuteMethod_VerifyValidInput(InformationInput);
string InputFetchLocation = ProcessFetchedInputsImplementation.GetTarget_InputFetchLocation(InformationInput);
ProcessInputFromStorageReturnValue ProcessInputFromStorageOutput = ProcessFetchedInputsImplementation.ExecuteMethod_ProcessInputFromStorage(parameters.ProcessingOperationName, InformationInput, InputFetchLocation);
ProcessFetchedInputsImplementation.ExecuteMethod_StoreObjects(ProcessInputFromStorageOutput.ProcessingResultsToStore);
ProcessFetchedInputsImplementation.ExecuteMethod_DeleteObjects(ProcessInputFromStorageOutput.ProcessingResultsToDelete);
}
public static void SendInputJoinEmail(TBEmailValidation emailValidation, InformationInput informationInput, string[] ownerEmailAddresses)
{
string urlLink = GetUrlLink(emailValidation.ID);
QueueSupport.ReportStatistics("Input Join Email sent! Link: " + urlLink, TimeSpan.FromDays(1));
// bool isAccount = emailValidation.InformationInputConfirmation.AccountID != null;
// string ownerID = isAccount
// ? emailValidation.InformationInputConfirmation.AccountID
// : emailValidation.InformationInputConfirmation.GroupID;
// string emailMessageFormat =
// @"Your confirmation is required to allow the following information source '{0}' to be fetched within {1} ID {2}.
//
//
//Click the following link to confirm this action:
//{3}";
// string message = String.Format(emailMessageFormat, informationInput.Description,
// isAccount ? "account" : "collaboration group", ownerID, urlLink);
// foreach (string emailAddress in ownerEmailAddresses)
// {
// SendEmail(FromAddress, emailAddress, "Information Input Confirmation", message);
// }
}
public void dataInputExecute(Object parameter)
{
this.informationInput = new InformationInput();
this.informationInput.ShowDialog();
}
public static void ExecuteMethod_StoreObject(InformationInput informationInput)
{
informationInput.StoreInformation();
}
public static void ExecuteMethod_DeleteInformationInput(InformationInput informationInput)
{
informationInput.DeleteInformationObject();
}
public static void ExecuteMethod_SetInputValidAndActiveValue(bool isValidAndActive, InformationInput informationInput)
{
informationInput.IsValidatedAndActive = isValidAndActive;
}
public static void ExecuteMethod_SendEmailConfirmation(InformationInput informationInput, TBEmailValidation emailValidation, string[] ownerEmailAddresses)
{
EmailSupport.SendInputJoinEmail(emailValidation, informationInput, ownerEmailAddresses);
}
public static string GetTarget_InputFetchLocation(InformationInput informationInput)
{
return(informationInput.RelativeLocation + "_Input");
}
/// <summary>
/// 录入物品
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void heatingTileClick(object sender, RoutedEventArgs e)
{
InformationInput input = new InformationInput();
input.Show();
}
public static TBEmailValidation GetTarget_EmailValidation(TBAccount owningAccount, TBCollaboratingGroup owningGroup, InformationInput informationInput, string[] ownerEmailAddresses)
{
TBEmailValidation emailValidation = new TBEmailValidation();
emailValidation.InformationInputConfirmation = new TBInformationInputConfirmation();
if (owningAccount != null && owningGroup != null)
{
throw new InvalidDataException("Both owning account and owning group cannot be defined");
}
if (owningAccount == null && owningGroup == null)
{
throw new InvalidDataException("Both owning account and owning group must not be null");
}
if (owningAccount != null)
{
emailValidation.InformationInputConfirmation.AccountID = owningAccount.ID;
}
if (owningGroup != null)
{
emailValidation.InformationInputConfirmation.GroupID = owningGroup.ID;
}
emailValidation.InformationInputConfirmation.InformationInputID = informationInput.ID;
emailValidation.ValidUntil = DateTime.UtcNow.AddMinutes(30);
emailValidation.Email = ownerEmailAddresses.FirstOrDefault();
if (emailValidation.Email == null)
{
throw new InvalidDataException("Owner must have at least one email address defined");
}
return(emailValidation);
}
public static ProcessFetchedInputs.ProcessInputFromStorageReturnValue ExecuteMethod_ProcessInputFromStorage(
string processingOperationName, InformationInput informationInput, string inputFetchLocation)
{
var result = new ProcessFetchedInputs.ProcessInputFromStorageReturnValue();
var targetBlob = StorageSupport.CurrActiveContainer.GetBlob(inputFetchLocation + "/bulkdump.all",
InformationContext.Current.Owner);
var rawData = targetBlob.DownloadText();
var parts = processingOperationName.Split(';');
processingOperationName = parts[0];
var parameter = parts.Length > 1 ? parts[1] : string.Empty;
using (var csv = new CsvReader(new StreamReader(GenerateStreamFromString(rawData)), false))
{
switch (processingOperationName)
{
case "AddNewStockCompanies":
var collAdd = StockCompanyCollection.RetrieveFromOwnerContent(InformationContext.Current.Owner, "default");
var reader = new JsonReader();
dynamic jsonData = reader.Read(rawData);
foreach (var jsonCompany in jsonData)
{
var jsonCompany1 = jsonCompany;
if (collAdd.CollectionContent.Count(x => x.Symbol == jsonCompany1.Symbol) == 0)
{
var stockCompany = new StockCompany
{
Symbol = jsonCompany1.Symbol,
CompanyName = jsonCompany1.Name
};
stockCompany.SetLocationAsOwnerContent(InformationContext.Current.Owner, stockCompany.ID);
collAdd.CollectionContent.Add(stockCompany);
stockCompany.StoreInformation();
}
}
collAdd.StoreInformationMasterFirst(InformationContext.Current.Owner, true);
break;
case "UpdateStockCompanies":
if (csv.FieldCount >= 11)
{
var coll = StockCompanyCollection.RetrieveFromOwnerContent(InformationContext.Current.Owner, "default");
while (csv.ReadNextRecord())
{
var collectionStockCompany = coll.CollectionContent.FirstOrDefault(x => x.Symbol == csv[0]);
if (collectionStockCompany != null)
{
var stockCompany = StockCompany.RetrieveFromOwnerContent(InformationContext.Current.Owner,
collectionStockCompany.ID);
if (stockCompany != null)
{
stockCompany.CompanyName = csv[1].Trim('"');
stockCompany.PriceActual = ConvertToDouble(csv[2]);
stockCompany.PriceHigh = ConvertToDouble(csv[4]);
stockCompany.PriceLow = ConvertToDouble(csv[5]);
stockCompany.PriceOpen = ConvertToDouble(csv[3]);
stockCompany.Change = ConvertToDouble(csv[6]);
stockCompany.ChangePercent = ConvertToDouble(csv[7]);
stockCompany.ChangeYTD = ConvertToDouble(csv[8]);
stockCompany.ChangePercentYTD = ConvertToDouble(csv[9]);
stockCompany.Volume = ConvertToLong(csv[10]);
stockCompany.StoreInformation();
}
}
}
}
break;
case "UpdateChart_Days":
{
var chartPointsDays = GetChartPointCollection(parameter, "days");
chartPointsDays.CollectionContent.Clear();
if (csv.FieldCount > 1)
{
csv.ReadNextRecord(); //ignore the header row
while (csv.ReadNextRecord())
{
chartPointsDays.CollectionContent.Insert(0, new ChartPoint
{
Timestamp = csv[0],
Value = ConvertToDouble(csv[1])
});
}
}
chartPointsDays.StoreInformation();
}
break;
case "UpdateChart_Months":
var chartPointsMonths = GetChartPointCollection(parameter, "months");
chartPointsMonths.CollectionContent.Clear();
if (csv.FieldCount > 1)
{
csv.ReadNextRecord(); //ignore the header row
while (csv.ReadNextRecord())
{
chartPointsMonths.CollectionContent.Insert(0, new ChartPoint
{
Timestamp = csv[0],
Value = ConvertToDouble(csv[1])
});
}
}
chartPointsMonths.StoreInformation();
break;
case "UpdateChart_Years":
var chartPointsYears = GetChartPointCollection(parameter, "years");
chartPointsYears.CollectionContent.Clear();
if (csv.FieldCount > 1)
{
csv.ReadNextRecord(); //ignore the header row
while (csv.ReadNextRecord())
{
var timestamp = csv[0];
if (timestamp.Length > 7)
{
timestamp = timestamp.Substring(0, 7);
}
chartPointsYears.CollectionContent.Insert(0, new ChartPoint
{
Timestamp = timestamp,
Value = ConvertToDouble(csv[1])
});
}
}
chartPointsYears.StoreInformation();
break;
default:
throw new NotImplementedException("The dynamic Operation Type is not yet implemented.");
}
}
return(result);
}
public static void ExecuteMethod_StoreObject(InformationInput createdInformationInput)
{
createdInformationInput.StoreInformation();
}
public static string GetTarget_InputFetchName(InformationInput informationInput)
{
// TODO: timestamped, incremental and other options supported, now just bulk
return("bulkdump.all");
}
public static void ExecuteMethod_FetchInputToStorage(IContainerOwner owner, string queryParameters, InformationInput informationInput, string inputFetchLocation, string inputFetchName)
{
string url = string.IsNullOrEmpty(queryParameters)
? informationInput.LocationURL
: informationInput.LocationURL + queryParameters;
WebRequest getRequest = WebRequest.Create(url);
var response = getRequest.GetResponse();
var stream = response.GetResponseStream();
var targetBlob = StorageSupport.CurrActiveContainer.GetBlob(inputFetchLocation + "/" + inputFetchName, owner);
targetBlob.UploadFromStream(stream);
}
public static CreateInformationInputReturnValue Get_ReturnValue(InformationInput createdInformationInput)
{
return(new CreateInformationInputReturnValue {
InformationInput = createdInformationInput
});
}
public static CreateInformationInputReturnValue Get_ReturnValue(InformationInput createdInformationInput)
{
return new CreateInformationInputReturnValue {InformationInput = createdInformationInput};
}
public static InformationInput GetTarget_InformationInput(IContainerOwner owner, string informationInputId)
{
return(InformationInput.RetrieveFromDefaultLocation(informationInputId, owner));
}
public static void ExecuteMethod_SetInputValidAndActiveValue(bool isValidAndActive, InformationInput informationInput)
{
informationInput.IsValidatedAndActive = isValidAndActive;
}
public static void ExecuteMethod_DeleteInformationInput(InformationInput informationInput)
{
informationInput.DeleteInformationObject();
}
