public JsonResult GetRecipientList(string ObserveId)
{
ObservesModel model = ObserveServiceManager.GetObserveById(ObserveId);
if (model.Users.Id == User.Identity.GetUserId())
{
List <RecipientsModel> listModel = ObserveServiceManager.GetRecipientList(ObserveId);
List <RecipientListOutputModel> output = new List <RecipientListOutputModel>();
foreach (RecipientsModel item in listModel)
{
RecipientListOutputModel outputModel = new RecipientListOutputModel()
{
RecipientId = item.Id,
Email = item.Email
};
output.Add(outputModel);
}
return(Json(output));
}
else
{
return(Json(JsonConvert.DeserializeObject("{ 'Status': 'Unauthorized' }")));
}
}
public int AddRecipient(string ObserveId, string Email)
{
ObservesModel model = ObserveServiceManager.GetObserveById(ObserveId);
if (model.Users.Id == User.Identity.GetUserId())
{
List <RecipientsModel> list = ObserveServiceManager.GetRecipientList(ObserveId);
if (list.Where(e => e.Email == Email).Count() == 0)
{
RecipientsModel newModel = new RecipientsModel()
{
Id = Guid.NewGuid().ToString(),
Observes = model,
Email = Email,
Deleted = false
};
ObserveServiceManager.AddRecipient(newModel);
return(1);
}
else
{
return(3);
}
}
else
{
return(2);
}
}
public static void DetectResponseIrregularity(string StepId, int Minutes)
{
ObserverDbContext _db = new ObserverDbContext();
StepsModel stepsModel = _db.Steps
.Where(e => e.Id == StepId)
.FirstOrDefault();
int minute = (int)DateTime.UtcNow.Subtract(stepsModel.CheckedTime).TotalMinutes;
try
{
if (minute > Minutes)
{
string ObservesId = ObserveServiceManager.GetObserveByStepId(StepId).Id;
ObservesModel model = _db.Observes.Where(r => r.Id == ObservesId).FirstOrDefault();
model.Status = 0;
_db.SaveChanges();
foreach (RecipientsModel item in model.List_Recipients.Where(e => e.Deleted == false).ToList())
{
EmailServiceManager.CatchErrorNotification(model.Name, item.Email);
}
}
} catch (NullReferenceException e)
{
e.ToString();
}
}
public async Task <JsonResult> ExecuteBatchStepByObserveId(string ObserveId)
{
ObserverDbContext _db = new ObserverDbContext();
ObservesModel model = _db.Observes
.Where(e => e.Id == ObserveId)
.FirstOrDefault();
if (model.Users.Id == User.Identity.GetUserId())
{
List <StepsModel> listModel = _db.Observes.Where(e => e.Id == ObserveId).FirstOrDefault().List_Steps.Where(e => e.Deleted == false).OrderBy(e => e.Order).ToList();
List <StepExecutionInputModel> inputList = new List <StepExecutionInputModel>();
PCMethodsModel pcMethodsModel = null;
foreach (StepsModel item in listModel)
{
string PC1 = null;
string PC2 = null;
int PCMethod = 0;
if (item.PC_Method != null)
{
pcMethodsModel = PCMethodServiceManager.GetPCMethodById(item.PC_Method.Id);
PC1 = pcMethodsModel.PC1;
PC2 = pcMethodsModel.PC2;
PCMethod = int.Parse(item.PC_Method.Id);
}
StepExecutionInputModel input = new StepExecutionInputModel()
{
Order = item.Order.GetValueOrDefault(),
Uri = item.Url,
Method = item.Method.GetValueOrDefault(),
PC_Method = PCMethod,
PC1 = item.PC1,
PC2 = item.PC2,
PC2Secret = item.PC2Secret,
CustomHeader = item.PredefinedHeader,
UseHeader = item.SetHeader.GetValueOrDefault(),
LabelPC1 = PC1,
LabelPC2 = PC2
};
inputList.Add(input);
}
return(Json(await StepServiceManager.ExecuteBatchStepReturningResult(inputList)));
}
else
{
StepExecutionOutputModel input = new StepExecutionOutputModel()
{
Status = "Unauthorized"
};
return(Json(input));
}
}
public static ObservesModel GetObserveById(string Id)
{
ObserverDbContext _db = new ObserverDbContext();
ObservesModel query = _db.Observes
.Where(e => e.Id == Id)
.FirstOrDefault();
return(query);
}
public JsonResult GetStepList(String ObserveId)
{
ObservesModel observesModel = ObserveServiceManager.GetObserveById(ObserveId);
if (observesModel.Users.Id == User.Identity.GetUserId())
{
List <StepsModel> modelList = StepServiceManager.GetStepListByObserveId(ObserveId);
List <StepListOutputModel> newList = new List <StepListOutputModel>();
foreach (StepsModel item in modelList)
{
string StringMethod = null;
string StringSetHeader = null;
if (item.Method == 1)
{
StringMethod = "GET";
}
else if (item.Method >= 2)
{
StringMethod = "POST";
}
if (item.SetHeader == 1)
{
StringSetHeader = "Yes";
}
else if (item.SetHeader == 0)
{
StringSetHeader = "No";
}
else if (item.SetHeader == 2)
{
StringSetHeader = "Pre";
}
StepListOutputModel newModel = new StepListOutputModel()
{
Id = item.Id,
Priority = item.Order.GetValueOrDefault(),
Url = item.Url,
Method = StringMethod,
SetHeader = StringSetHeader
};
newList.Add(newModel);
}
return(Json(newList));
}
else
{
return(Json(JsonConvert.DeserializeObject("{ 'Status' = 'Unauthorized Access' }")));
}
}
public static void AddRecipient(RecipientsModel model)
{
ObserverDbContext _db = new ObserverDbContext();
ObservesModel observesModel = _db.Observes
.Where(e => e.Id == model.Observes.Id)
.FirstOrDefault();
model.Observes = observesModel;
_db.Recipients.Add(model);
_db.SaveChanges();
}
public static void UpdateObserve(ObservesModel model)
{
ObserverDbContext _db = new ObserverDbContext();
var query = _db.Observes
.Where(e => e.Id == model.Id)
.FirstOrDefault();
query.Status = model.Status;
query.Name = model.Name;
_db.SaveChanges();
}
public async Task <JsonResult> ExecuteStep(string StepId)
{
ObserverDbContext _db = new ObserverDbContext();
StepsModel stepsModel = _db.Steps
.Where(e => e.Id == StepId)
.FirstOrDefault();
ObservesModel observesModel = stepsModel.Observes;
if (observesModel.Users.Id == User.Identity.GetUserId())
{
string pcMethodsModelId = null;
string LabelPC1 = null;
string LabelPC2 = null;
int pcMethodsModelIdInt = 0;
if (stepsModel.PC_Method != null)
{
pcMethodsModelId = stepsModel.PC_Method.Id;
LabelPC1 = stepsModel.PC_Method.PC1;
LabelPC2 = stepsModel.PC_Method.PC2;
pcMethodsModelIdInt = int.Parse(pcMethodsModelId);
}
StepExecutionInputModel input = new StepExecutionInputModel()
{
Order = stepsModel.Order.GetValueOrDefault(),
Uri = stepsModel.Url,
Method = stepsModel.Method.GetValueOrDefault(),
PC_Method = pcMethodsModelIdInt,
PC1 = stepsModel.PC1,
PC2 = stepsModel.PC2,
CustomHeader = stepsModel.PredefinedHeader,
PredefinedHeader = stepsModel.SetHeader.GetValueOrDefault(),
LabelPC1 = LabelPC1,
LabelPC2 = LabelPC2,
PC2Secret = stepsModel.PC2Secret
};
return(Json(await StepServiceManager.ExecuteStepReturningResult(input)));
}
else
{
StepExecutionOutputModel input = new StepExecutionOutputModel()
{
Status = "Unauthorized"
};
return(Json(input));
}
}
public int DeleteObserveById(string Id)
{
ObservesModel model = ObserveServiceManager.GetObserveById(Id);
if (model.Users.Id == User.Identity.GetUserId())
{
ObserveServiceManager.DeleteObserveById(Id);
return(1);
}
else
{
return(2);
}
}
public int SetIntervalByObserveId(string ObserveId, int Interval)
{
ObservesModel model = ObserveServiceManager.GetObserveById(ObserveId);
if (model.Users.Id == User.Identity.GetUserId())
{
ObserveServiceManager.SetIntervalByObserveId(ObserveId, Interval);
return(1);
}
else
{
return(2);
}
}
public int SetCatchByStepId(string StepId, string CatchId)
{
ObservesModel model = ObserveServiceManager.GetObserveByStepId(StepId);
if (model.Users.Id == User.Identity.GetUserId())
{
StepServiceManager.SetCatchByStepId(StepId, CatchId);
return(1);
}
else
{
return(2);
}
}
public static ObservesModel GetObserveByStepId(string StepId)
{
ObserverDbContext _db = new ObserverDbContext();
string observeId = _db.Steps
.Where(e => e.Id == StepId)
.FirstOrDefault()
.Observes.Id;
ObservesModel query = _db.Observes
.Where(e => e.Id == observeId)
.FirstOrDefault();
return(query);
}
public int SetObserveStatus(string Id, int Status)
{
ObservesModel model = ObserveServiceManager.GetObserveById(Id);
if (model.Users.Id == User.Identity.GetUserId())
{
model.Status = Status;
ObserveServiceManager.UpdateObserve(model);
return(1);
}
else
{
return(2);
}
}
public int SetObserveName(string Id, string Name)
{
ObservesModel model = ObserveServiceManager.GetObserveById(Id);
if (model.Users.Id == User.Identity.GetUserId())
{
model.Name = Name;
ObserveServiceManager.UpdateObserve(model);
return(1);
}
else
{
return(2);
}
}
public static ObservesModel GetObservesByRecipientId(string RecipientId)
{
ObserverDbContext _db = new ObserverDbContext();
string observeId = _db.Recipients
.Where(e => e.Id == RecipientId)
.FirstOrDefault()
.Observes
.Id;
ObservesModel query = _db.Observes
.Where(e => e.Id == observeId)
.FirstOrDefault();
return(query);
}
public static void CreateObserve(string AspId, string Name)
{
ObserverDbContext _db = new ObserverDbContext();
UsersModel user = _db.Users.Where(e => e.Id == AspId).FirstOrDefault();
ObservesModel model = new ObservesModel()
{
Id = Guid.NewGuid().ToString(),
Name = Name,
Status = 0,
Users = user,
DateCreated = DateTime.UtcNow,
Deleted = false,
Interval = 0,
NextRun = DateTime.UtcNow
};
_db.Observes.Add(model);
_db.SaveChanges();
}
public int ReorderStep(ReorderStepInputModel model)
{
ObservesModel observesModel = ObserveServiceManager.GetObserveById(model.ObserveId);
if (observesModel.Users.Id == User.Identity.GetUserId())
{
if (model.initOrder == model.minOrder)
{
StepServiceManager.ReorderStepDesc(model.ObserveId, model.minOrder, model.maxOrder);
return(1);
}
else
{
StepServiceManager.ReorderStepAsc(model.ObserveId, model.minOrder, model.maxOrder);
return(1);
}
}
else
{
return(2);
}
}
public JsonResult SetPredefinedHeader(string StepId, string Header, string Code)
{
ObserverDbContext _db = new ObserverDbContext();
Header = Regex.Replace(Header, @"\s+", "");
var query = _db.Steps
.Where(e => e.Id == StepId)
.FirstOrDefault();
if (query.Observes.Users.ApiCode == Code)
{
query.PredefinedHeader = Header;
ObservesModel observesModel = _db.Steps.Where(e => e.Id == StepId).FirstOrDefault().Observes;
observesModel.Status = 1;
_db.SaveChanges();
return(Json(new JavaScriptSerializer().Deserialize <object>("{ 'Status': 'Success' }"), JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new JavaScriptSerializer().Deserialize <object>("{ 'Status': 'Unauthorized' }"), JsonRequestBehavior.AllowGet));
}
}
/*
* Method
* 1 - No previous step
* 2 - Insert new step as level 1 priority
* 3 - Insert new step as last level priority
*/
public static bool CreateStep(string AspId, StepsModel model, int Method, string ObserveId)
{
ObserverDbContext _db = new ObserverDbContext();
ObservesModel queryModel = _db.Observes
.Where(e => e.Id == ObserveId)
.FirstOrDefault();
try
{
if (model.PC_Method.Id != null)
{
PCMethodsModel pcMethodsModel = _db.PCMethods.Where(e => e.Id == model.PC_Method.Id).FirstOrDefault();
model.PC_Method = pcMethodsModel;
}
} catch (NullReferenceException e)
{
e.ToString();
}
if (AspId == queryModel.Users.Id)
{
model.Observes = queryModel;
model.CheckedTime = DateTime.UtcNow;
if (Method == 1)
{
model.Order = 1;
_db.Steps.Add(model);
_db.SaveChanges();
}
else if (Method == 2)
{
var modelList = _db.Steps
.Where(e => e.Observes.Id == ObserveId)
.OrderByDescending(e => e.Order)
.ToList();
foreach (StepsModel item in modelList)
{
item.Order = item.Order + 1;
}
model.Order = 1;
_db.Steps.Add(model);
_db.SaveChanges();
}
else if (Method == 3)
{
int countStep = _db.Steps
.Where(e => e.Observes.Id == model.Observes.Id && e.Deleted == false)
.Count();
model.Order = countStep + 1;
_db.Steps.Add(model);
_db.SaveChanges();
}
return(true);
}
else
{
return(false);
}
}
public ActionResult Modify(string id)
{
if (Request.Browser.IsMobileDevice)
{
return(RedirectToAction("ModifyM"));
}
ObservesModel model = ObserveServiceManager.GetObserveById(id);
List <StepsModel> oriList = StepServiceManager.GetStepListByObserveId(id);
List <PCMethodsModel> methodList = PCMethodServiceManager.GetPCMethodList().OrderBy(e => e.Name).ToList();
List <StepListOutputModel> newList = new List <StepListOutputModel>();
List <PCMethodOutputModel> PCMethodOutput = new List <PCMethodOutputModel>();
foreach (StepsModel item in oriList)
{
string StringMethod = null;
string StringSetHeader = null;
if (item.Method == 1)
{
StringMethod = "GET";
}
else if (item.Method >= 2)
{
StringMethod = "POST";
}
if (item.SetHeader == 1)
{
StringSetHeader = "Yes";
}
else if (item.SetHeader == 0)
{
StringSetHeader = "No";
}
else if (item.SetHeader == 2)
{
StringSetHeader = "Pre";
}
StepListOutputModel newModel = new StepListOutputModel()
{
Id = item.Id,
Priority = item.Order.GetValueOrDefault(),
Url = item.Url,
Method = StringMethod,
SetHeader = StringSetHeader
};
newList.Add(newModel);
}
foreach (PCMethodsModel item in methodList)
{
PCMethodOutputModel newModel = new PCMethodOutputModel()
{
Id = item.Id,
Name = item.Name
};
PCMethodOutput.Add(newModel);
}
try
{
ObserveOutputModel output = new ObserveOutputModel()
{
Id = model.Id,
Name = model.Name,
Status = model.Status.GetValueOrDefault(),
Interval = model.Interval.GetValueOrDefault(),
StepList = newList,
PCMethod = PCMethodOutput
};
return(View(output));
} catch (NullReferenceException e)
{
return(RedirectToAction("Index", "Observe"));
}
}
public int CreateNewStep(StepCreationInputModel model)
{
if (model.Url == null)
{
return(1);
}
else if (model.Method != 1 && model.Method != 2)
{
return(2);
}
else if (model.Priority != 1 && model.Priority != 2)
{
return(3);
}
else
{
ObserverDbContext _db = new ObserverDbContext();
ObservesModel observesModel = _db.Observes
.Where(e => e.Id == model.ObserveId)
.FirstOrDefault();
PCMethodsModel pcMethodsModel = _db.PCMethods
.Where(e => e.Id == model.ContentMethod.ToString())
.FirstOrDefault();
byte[] encrypt = null;
byte[] encryptSecret = null;
string encrypted = null;
string encryptedSecret = null;
if (model.PC2 != null)
{
byte[] secretKey = Convert.FromBase64String(_db._AESSecretKeyS);
using (AesManaged myAes = new AesManaged())
{
encrypt = EncryptionAlgorithmServiceManager.EncryptStringToBytes_Aes(model.PC2, secretKey, myAes.IV);
encryptSecret = myAes.IV;
}
}
if (encrypt != null)
{
encrypted = Convert.ToBase64String(encrypt);
encryptedSecret = Convert.ToBase64String(encryptSecret);
}
StepsModel stepsModel = new StepsModel()
{
Id = Guid.NewGuid().ToString(),
Url = model.Url,
Method = model.Method,
SetHeader = model.Header,
Deleted = false,
PredefinedHeader = model.PredefinedHeader,
PC_Method = pcMethodsModel,
PC1 = model.PC1,
PC2 = encrypted,
PC2Secret = encryptedSecret
};
int numStep = StepServiceManager.GetStepListByObserveId(model.ObserveId).Count();
if (numStep == 0)
{
if (StepServiceManager.CreateStep(User.Identity.GetUserId(), stepsModel, 1, model.ObserveId))
{
return(4);
}
else
{
return(5);
}
}
else
{
if (model.Priority == 1)
{
if (StepServiceManager.CreateStep(User.Identity.GetUserId(), stepsModel, 2, model.ObserveId))
{
return(4);
}
else
{
return(5);
}
}
if (model.Priority == 2)
{
if (StepServiceManager.CreateStep(User.Identity.GetUserId(), stepsModel, 3, model.ObserveId))
{
return(4);
}
else
{
return(5);
}
}
return(4);
}
}
}
