/ - Diff - D-Net - D-Net project tracking tool

     import eu.dnetlib.clients.pimpa.PimpaStubFactory;
     import eu.dnetlib.data.db.AffiliationsDao;
     import eu.dnetlib.data.utils.IstiConstants;
     import eu.dnetlib.data.utils.XsltFunctions;
     import eu.dnetlib.msro.workflows.graph.Arc;
     import eu.dnetlib.msro.workflows.procs.Env;
     import eu.dnetlib.rmi.manager.MSROException;
     @Deprecated
     public class PimpaUpdateJobNode extends SimpleJobNode {
     	@Autowired
-...
     	@Override
     	protected String execute(final Env env) throws Exception {
     		throw new MSROException("THIS NODE IS DEPRECATED");
     		// return _execute(env);
+    	}
     	private String _execute(final Env env) throws Exception {
     		log.info("Reimport records from PIMPA - START");
     		final Map<String, Boolean> oldPids = dao.getPersonIds().stream().collect(Collectors.toMap(s -> s, s -> true));
-...
     							final String pid = "matricola:" + p.getCode().trim();
     							if (!oldPids.containsKey(pid)) {
     								dao.registerPerson(pid, String.format("%s %s", p.getName().trim(), p.getSurname().trim()));
     								dao.registerPerson(pid, p.getName().trim(), p.getSurname().trim());
     								oldPids.put(pid, false);
     							} else if (overridePersons && oldPids.get(pid)) {
     								log.info("Overriding person " + pid);
     								dao.updatePerson(pid, String.format("%s %s", p.getName().trim(), p.getSurname().trim()));
     								dao.updatePerson(pid, p.getName().trim(), p.getSurname().trim());
     								oldPids.put(pid, false);
+    							}
     							p.getLabs().getList().forEach(lab -> {
-...
     				});
     		if (capitalizeFullnames) {
     			log.info("Capitalizing person fullnames");
     			dao.listPersons().forEach(p -> {
     				dao.updatePerson(p.getId(), XsltFunctions.capitalize(p.getName()));
     			});;
     			log.info("Capitalizing person fullnames - DEPRECATED - NOT PERFROMED");
     			// dao.listPersons().forEach(p -> { dao.updatePerson(p.getId(), XsltFunctions.capitalize(p.getName())); });;
+    		}
     		log.info("Reimport records from PIMPA - END");

     	public static String calculatePersonName(final String s) {
     		final Pattern pattern = Pattern.compile("info:cnr-pdr\\/author\\/(.+):(.+)\\/(.+)\\/(.+)");
     		final Matcher matcher = pattern.matcher(s);
     		return matcher.find() ? capitalize(String.format("%s %s", matcher.group(4), matcher.group(3))) : "";
     		return matcher.find() ? capitalize(String.format("%s, %s", matcher.group(3), matcher.group(4))) : "";
+    	}
     	public static String serverName(final String s) {

     public class Person {
     	private String id;
     	private String name;
     	private String fullname;
     	private SortedMap<Integer, Set<Group>> affiliations = new TreeMap<>();
     	public Person() {}
     	public Person(final String id, final String name) {
     	public Person(final String id, final String fullname) {
     		this.id = id;
     		this.name = name;
     		this.fullname = fullname;
+    	}
     	public String getId() {
-...
     		this.id = id;
+    	}
     	public String getName() {
     		return name;
     	public String getFullname() {
     		return fullname;
+    	}
     	public void setName(final String name) {
     		this.name = name;
     	protected void setFullname(final String fullname) {
     		this.fullname = fullname;
+    	}
     	public SortedMap<Integer, Set<Group>> getAffiliations() {
-...
     	@Override
     	public String toString() {
     		return "Person [id=" + id + ", name=" + name + ", affiliations=" + affiliations + "]";
     		return "Person [id=" + id + ", fullname=" + fullname + ", affiliations=" + affiliations + "]";
+    	}
+    }

     			final Integer year = (Integer) map.get("year");
     			final Group group = new Group((String) map.get("gid"), (String) map.get("gname"), (String) map.get("gtype"));
     			temp.putIfAbsent(pid, new Person(pid, (String) map.get("pname")));
     			temp.putIfAbsent(pid, new Person(pid, (String) map.get("pfullname")));
     			if (year != null) {
     				temp.get(pid).getAffiliations().putIfAbsent(year, new TreeSet<>((g1, g2) -> {
-...
     		return temp.values()
     				.stream()
     				.sorted((p1, p2) -> p1.getName().compareTo(p2.getName()))
     				.sorted((p1, p2) -> p1.getFullname().compareTo(p2.getFullname()))
     				.collect(Collectors.toList());
+    	}
-...
+    		}
+    	}
     	public List<Person> listPersons() {
     		return jdbcTemplate.query("select * from persons", (RowMapper<Person>) (rs, rowNum) -> {
     			return new Person(rs.getString("id"), rs.getString("fullname"));
     		});
+    	}
     	public List<Group> listGroups() {
     		return jdbcTemplate.query("select * from groups where id != 'UNKNOWN'", (RowMapper<Group>) (rs, rowNum) -> {
     			return new Group(rs.getString("id"), rs.getString("name"), rs.getString("type"));
-...
     		return new HashSet<>(jdbcTemplate.query("select id from groups", (RowMapper<String>) (rs, rowNum) -> rs.getString("id")));
+    	}
     	public void updatePerson(final String code, final String name) {
     		jdbcTemplate.update("UPDATE persons SET fullname = ? WHERE id = ?", name, code);
     	public void updatePerson(final String code, final String name, final String surname) {
     		jdbcTemplate.update("UPDATE persons SET name=?, surname=? WHERE id=?", name, surname, code);
+    	}
     	public void registerPerson(final String code, final String name) {
     		jdbcTemplate.update("INSERT into persons(id, fullname) VALUES (?, ?)", code, name);
     	public void registerPerson(final String code, final String name, final String surname) {
     		jdbcTemplate.update("INSERT into persons(id, name, surname) VALUES (?, ?, ?)", code, name, surname);
+    	}
     	public void updateGroup(final String id, final String name, final String type) {
     		jdbcTemplate.update("UPDATE groups SET (name, type) = (?, ?) WHERE id = ?", name, type, id);
     		jdbcTemplate.update("UPDATE groups SET name=?, type=? WHERE id=?", name, type, id);
+    	}
     	public void registerGroup(final String id, final String name, final String type) {

     import org.springframework.web.bind.annotation.RequestBody;
     import org.springframework.web.bind.annotation.RequestMapping;
     import org.springframework.web.bind.annotation.RequestMethod;
     import org.springframework.web.bind.annotation.RestController;
     import eu.dnetlib.data.db.Affiliation;
     import eu.dnetlib.data.db.AffiliationsDao;
     import eu.dnetlib.data.db.Group;
     import eu.dnetlib.data.db.Person;
     @RestController
     // @RestController
     @Deprecated
     public class AffiliationsAjaxController {
     	@Autowired
-...
     	@RequestMapping(value = "/ui/portal/aff_view", method = RequestMethod.GET)
     	public Map<String, List<Person>> persons() {
     		return dao.listPersonsWithAffiliations().stream().collect(Collectors.groupingBy(Person::getName, TreeMap::new, Collectors.toList()));
     		return dao.listPersonsWithAffiliations().stream().collect(Collectors.groupingBy(Person::getFullname, TreeMap::new, Collectors.toList()));
+    	}
     	@RequestMapping(value = "/ui/portal/groups", method = RequestMethod.GET)

modules/dnet-isti/trunk/src/main/java/eu/dnetlib/data/db/ui/AffiliationsEntryPointController.java
7	7
8	8	import eu.dnetlib.functionality.modular.ui.ModuleEntryPoint;
9	9
	10	@Deprecated
10	11	public class AffiliationsEntryPointController extends ModuleEntryPoint {
11	12
12	13	@Override

     	@Override
     	protected void reconfigure(final Map<String, String> params) {
     		affiliations = dao.listPersonsWithAffiliations()
     				.stream()
     				.collect(Collectors.toMap(Person::getId, a -> a));
     		affiliations = dao.listPersonsWithAffiliations().stream().collect(Collectors.toMap(Person::getId, a -> a));
+    	}
     	@Override
-...
     				final Matcher matcher = pattern.matcher(infoId);
     				if (matcher.find()) {
     					final String code = matcher.group(1);
     					final String fullname = XsltFunctions.capitalize(String.format("%s %s", matcher.group(3), matcher.group(2)));
     					final String surname = matcher.group(2);
     					final String name = matcher.group(3);
     					final Person p = affiliations.get(code);
     					if (p != null) {
     						final Set<Group> groups = p.getAffiliations().get(year);
     						if (groups != null) {
     							cp.setName(p.getName());
     							cp.setName(p.getFullname());
     							for (final Group g : groups) {
     								if (!g.getId().equals(UNKNOWN_GROUP.getId())) {
     									cp.getAffiliations().add(new Affiliation(code, g.getType(), g.getId(), g.getName()));
     									cp.getAffiliations().add(new Affiliation(code,
     											g.getType(), g.getId(), g.getName()));
+    								}
+    							}
     						} else {
     							log.info("Affiliation not found, infoId: " + infoId + ", year: " + year);
     							log.info("Affiliation not found, infoId: " +
     									infoId + ", year: " + year);
     							dao.registerAffiliation(code, UNKNOWN_GROUP.getId(), year);
     							p.getAffiliations().put(year, Sets.newHashSet(UNKNOWN_GROUP));
+    						}
     					} else {
     						log.info("Person not found, infoId: " + infoId + ", year: " + year);
     						dao.registerPerson(code, fullname);
     						dao.registerPerson(code, XsltFunctions.capitalize(name), XsltFunctions.capitalize((surname)));
     						dao.registerAffiliation(code, UNKNOWN_GROUP.getId(), year);
     						final Person np = new Person(code, fullname);
     						final Person np = new Person(code, String.format("%s, %s", surname, name));
     						np.getAffiliations().put(year, Sets.newHashSet(UNKNOWN_GROUP));
     						affiliations.put(code, np);

     CREATE TABLE persons (
     	id       varchar(32) PRIMARY KEY,
     	fullname varchar(256) NOT NULL
     	name     varchar(256) NOT NULL,
     	surname  varchar(256) NOT NULL,
     	suffix   varchar(256)
     );
     CREATE TABLE groups (
-...
     INSERT INTO groups(id, name, type) VALUES ('UNKNOWN', 'UNKNOWN', 'UNKNOWN');
     CREATE VIEW affiliations_view AS	SELECT
     	p.id       as pid,
     	p.fullname as pname,
     	g.id       as gid,
     	g.name     as gname,
     	g.type     as gtype,
     	a.year     as year
     CREATE VIEW affiliations_view AS SELECT
     	p.id                                                               as pid,
     	TRIM(CONCAT(p.surname, ", ", p.name, " ", COALESCE(p.suffix, ''))) as pfullname,
     	p.fullname                                                         as pname,  //TODO DA TOGLIERE
     	g.id                                                               as gid,
     	g.name                                                             as gname,
     	g.type                                                             as gtype,
     	a.year                                                             as year
     FROM
     	persons p
     	LEFT OUTER JOIN affiliations a ON (p.id = a.pid)

     	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
     	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
     	<bean name="/ui/affiliations.do"
     	<!-- <bean name="/ui/affiliations.do"
     		class="eu.dnetlib.data.db.ui.AffiliationsEntryPointController"
     		p:menu="Affiliations Database"
     		p:title="Affiliations Database"
-...
     			</set>
     		</property>
     	</bean>
     	-->
     </beans>

Project

General

Profile

D-Net

Revision 60657

Added by Michele Artini about 3 years ago