void IOracleModelVisitor.VisitSynonym(SynonymModel item)
{
if (this._filter(item))
{
_items.Add(item);
}
}
/// <summary>
/// create_synonym :
/// CREATE(OR REPLACE)? PUBLIC SYNONYM synonym_name FOR(objectSchema= schema_name PERIOD)? objectName=schema_object_name(AT_SIGN link_name)?
/// | CREATE(OR REPLACE)? SYNONYM(schema= schema_name PERIOD)? synonym_name FOR(objectSchema= schema_name PERIOD)? objectName=schema_object_name(AT_SIGN link_name)?
/// ; ;
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override object VisitCreate_synonym([NotNull] PlSqlParser.Create_synonymContext context)
{
var ispublic = context.PUBLIC() != null;
string synonym_schema = context.Schema_synonym.GetCleanedTexts().FirstOrDefault();
if (string.IsNullOrEmpty(synonym_schema))
{
synonym_schema = ispublic
? "PUBLIC"
: string.Empty;
}
var synonym_name = context.synonym_name().GetCleanedTexts().FirstOrDefault();
var object_schema = context.objectSchema.GetCleanedTexts().FirstOrDefault();
var object_name = context.objectName.GetCleanedTexts().FirstOrDefault();
string link_name = context.link_name().GetCleanedTexts().FirstOrDefault() ?? string.Empty;
SynonymModel synonym = AppendSynonym(context.REPLACE() != null, ispublic, synonym_schema, synonym_name, object_schema, object_name, link_name, context);
AppendFile(synonym, context.Start);
Debug.Assert(synonym != null);
return(synonym);
}
private void Append(SynonymModel source, DifferenceModel d)
{
string p = BuildPath(Path.Combine(this.folderForTarget, source.ObjectTargetOwner), "Synonyms", source.Name);
StringBuilder sb = new StringBuilder();
if (!File.Exists(p))
{
var file = source.Files.OfType <FileElement>().FirstOrDefault();
if (file != null && file.Exist(this.rootFolderSource))
{
sb = new StringBuilder(Helpers.ContentHelper.LoadContentFromFile(this.rootFolderSource, file.Path));
}
else
{
sb.Append(string.Format("CREATE OR REPLACE {0} SYNONYM {1}.{2} FOR {3};", "PUBLIC", source.ObjectTargetOwner, source.Name, source.ObjectTargetName));
}
if (sb.Length > 0)
{
WriteFile(p, sb.ToString());
d.Addfile(p);
}
}
}
public void VisitSynonym(SynonymModel item)
{
if (InFile(item))
{
_sequenceToDelete.Add(item);
}
}
public override void AppendMissing(SynonymModel source)
{
if (_buckets.Add(source))
{
var d = base.AppendDifference(source, false);
Append(source, d);
}
}
public override void AppendChange(SynonymModel source, SynonymModel target, string propertyName)
{
if (_buckets.Add(source))
{
var d = base.AppendDifference(source, target, propertyName);
Append(source, d);
}
}
public void Post(SynonymModel model)
{
//Determine the next ID
var id = _context.Synonyms.Select(x => x.Id).Max() + 1; //In memory DB...that's why.
model.Id = id;
_context.Synonyms.Add(model);
_context.SaveChanges();
}
public SynonymModel Update(SynonymModel model)
{
if (!SynonymStorage.SynonymKeys.Contains(model.KeyWord))
{
throw new ArgumentException("This word doesn´t exist!");
}
AddSynonymRange(model.KeyWord, model.Synonyms);
UpdateExisting(model.KeyWord, model.Synonyms);
return(model);
}
public SynonymModel Add(SynonymModel model)
{
if (SynonymStorage.SynonymKeys.Contains(model.KeyWord))
{
throw new ArgumentException("This word is already in store!");
}
//Use one dictionary for storage and one HashSet for storing keys enabling faster search
SynonymStorage.Synonyms.Add(model.KeyWord, model.Synonyms);
SynonymStorage.SynonymKeys.Add(model.KeyWord);
UpdateExisting(model.KeyWord, model.Synonyms);
return(model);
}
public ActionResult getSynonyms(PageRankModel model)
{
if (ModelState.IsValid)
{
string[] words = model.keywords.Split(' ');
SynonymModel synonymModel = new SynonymModel();
synonymModel.keywords = words;
synonymModel.synonyms = handler.semanticAnalysis(model.keywords);
synonymModel.arraySize = words.Length;
return(Json(synonymModel, JsonRequestBehavior.AllowGet));
}
return(Json("Error", JsonRequestBehavior.AllowGet));
}
public ActionResult Add(SynonymModel model)
{
if (ModelState.IsValid)
{
_synonymService.Add(new SynonymDto
{
Term = model.Term,
Synonyms = model.Synonyms.Split(',').ToList()
});
return(Json(new { success = true, message = "Synonym added to database" }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { sucess = false, message = "Model is invalid." }, JsonRequestBehavior.AllowGet));
}
}
public virtual void AppendChange(SynonymModel source, SynonymModel target, string propertyName)
{
AppendDifference(source, target, propertyName);
if (generateSource)
{
string p = BuildPath(Path.Combine(this.folderForSource, source.ObjectTargetOwner), "Synonyms", source.Name);
if (!File.Exists(p))
{
string sql = string.Empty;
if (source.Owner == "PUBLIC")
{
sql = string.Format("CREATE OR REPLACE PUBLIC SYNONYM {0} FOR {1};", source.Name, source.ObjectTargetName);
}
else
{
sql = string.Format("CREATE OR REPLACE SYNONYM {1}.{2} FOR {3};", p, source.Owner, source.Name, source.ObjectTargetName);
}
WriteFile(p, sql);
}
}
if (generateTarget)
{
string p = BuildPath(Path.Combine(this.folderForTarget, target.ObjectTargetOwner), "Synonyms", target.Name);
if (!File.Exists(p))
{
string sql = string.Empty;
if (source.Owner == "PUBLIC")
{
sql = string.Format("CREATE OR REPLACE PUBLIC SYNONYM {0} FOR {1};", source.Name, source.ObjectTargetName);
}
else
{
sql = string.Format("CREATE OR REPLACE SYNONYM {1}.{2} FOR {3};", p, source.Owner, source.Name, source.ObjectTargetName);
}
WriteFile(p, sql);
}
}
}
private SynonymModel AppendSynonym(bool withReplace, bool ispublic, string synonym_schema, string synonym_name, string object_schema, string object_name, string link_name, ParserRuleContext context)
{
string p = ispublic ? "public" : string.Empty;
string key = $"{p}:{synonym_schema}.{synonym_name}:{object_schema}.{object_name}:{link_name}";
var synonym = new SynonymModel()
{
Key = key,
Owner = synonym_schema,
Name = synonym_name,
ObjectTargetOwner = object_schema,
ObjectTargetName = object_name,
DbLink = link_name,
IsPublic = ispublic,
};
if (withReplace)
{
AppendEventParser(
"duplicate object",
$"{synonym_schema}.{synonym_name}",
Models.KindModelEnum.Synonym,
context,
synonym.Files
);
Append(new OCreateOrReplace()
{
Item = synonym
});
}
else
{
Append(synonym);
}
return(synonym);
}
public SynonymsController(SynonymModel synonymModel)
{
this.synonymModel = synonymModel;
}
public virtual void AppendToRemove(SynonymModel target)
{
AppendDifference(target, true);
}
public void Put(SynonymModel model)
{
_context.Synonyms.Update(model);
_context.SaveChanges();
}
public override List <SynonymTable_11> Resolve(DbContextOracle context, Action <SynonymTable_11> action)
{
List <SynonymTable_11> List = new List <SynonymTable_11>();
var db = context.Database;
this.OracleContext = context;
if (action == null)
{
action =
t =>
{
if (!context.Use(t.SYNONYME_OWNER))
{
return;
}
string key = string.Empty;
if (!string.IsNullOrEmpty(t.SYNONYME_OWNER))
{
key = $"{t.SYNONYME_OWNER}.";
}
else
{
}
key += $"{t.SYNONYME_NAME}:{t.OBJECT_OWNER}.{t.OBJECT_NAME}:{t.DB_LINK ?? string.Empty}";
if (!string.IsNullOrEmpty(t.OBJECT_OWNER))
{
if (!ContextLoader.excluded.Contains(t.OBJECT_OWNER))
{
var syn = new SynonymModel()
{
Key = key,
//ObjectType = t.OBJECT_TYPE,
ObjectTargetName = t.OBJECT_NAME,
Name = t.SYNONYME_NAME,
ObjectTargetOwner = t.OBJECT_OWNER,
Owner = t.SYNONYME_OWNER,
IsPublic = t.SYNONYME_OWNER.ToUpper() == "PUBLIC",
DbLink = t.DB_LINK ?? string.Empty,
};
db.Synonyms.Add(syn);
}
}
}
}
;
SynonymDescriptor_11 view = new SynonymDescriptor_11(context.Manager.ConnectionString);
var c = (TableQueryAndCondition("o", "OBJECT_OWNER")
+ " OR " + GetQueryCondition("t", "OWNER", "")).Trim().Substring(3);
sql = string.Format(sql, " WHERE " + c);
using (var reader = context.Manager.ExecuteReader(CommandType.Text, sql))
{
List = view.ReadAll(reader, action).ToList();
}
return(List);
}
}
public async Task <IActionResult> Put(SynonymModel synonymModel)
{
var result = await _mediator.Send(new UpdateSynonym(synonymModel));
return(new OkObjectResult(result));
}
public async Task <IActionResult> Post(SynonymModel synonymModel)
{
var result = await _mediator.Send(new AddSynonym(synonymModel));
return(Created($"/{result.KeyWord}", result));
}
public void Delete(SynonymModel model)
{
_context.Synonyms.Remove(model);
_context.SaveChanges();
}
protected virtual void Visit(SynonymModel source, SynonymModel target, TypeDifferenceEnum kind, string propertyName, DifferenceModel item)
{
}
